@kimposoft/plugin-sdk 0.0.0-stage → 1.1.0-tp.22
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +202 -0
- package/NOTICE +9 -0
- package/README.md +48 -2
- package/package.json +145 -4
- package/src/action-designer.ts +267 -0
- package/src/attachment-open.ts +574 -0
- package/src/attachment-url.ts +235 -0
- package/src/auth/index.ts +6 -0
- package/src/auth/qrcode.ts +519 -0
- package/src/auth/types.ts +261 -0
- package/src/display-style.ts +532 -0
- package/src/editor-frame.ts +625 -0
- package/src/editor-session.ts +1214 -0
- package/src/editor-testing.ts +838 -0
- package/src/editor.ts +1720 -0
- package/src/frame-transport.ts +516 -0
- package/src/frontend-routes.ts +99 -0
- package/src/hooks.ts +48 -0
- package/src/host-caps.ts +93 -0
- package/src/i18n.ts +238 -0
- package/src/im-panel.ts +132 -0
- package/src/image-tools.ts +91 -0
- package/src/index.ts +125 -0
- package/src/interactive-session.ts +94 -0
- package/src/nahida-im.ts +391 -0
- package/src/nahida-ws.ts +23 -0
- package/src/org-directory.ts +78 -0
- package/src/oz-realtime.ts +144 -0
- package/src/page.ts +591 -0
- package/src/print.ts +393 -0
- package/src/surface.ts +310 -0
- package/src/theme-mocks.ts +140 -0
- package/src/theme.ts +125 -0
- package/src/ui-fixtures/attachment.ts +24 -0
- package/src/ui-fixtures/confirm.ts +16 -0
- package/src/ui-fixtures/entity-picker.ts +24 -0
- package/src/ui-fixtures/expression-editor.ts +52 -0
- package/src/ui-fixtures/image-cropper.ts +23 -0
- package/src/ui-fixtures/index.ts +17 -0
- package/src/ui-fixtures/org-tri-picker.ts +19 -0
- package/src/ui-fixtures/prompt.ts +19 -0
- package/src/ui-fixtures/record-picker.ts +17 -0
- package/src/ui-fixtures/template-picker.ts +13 -0
- package/src/ui-mocks.ts +264 -0
- package/src/ui.ts +491 -0
- package/src/workflow-designer.ts +475 -0
|
@@ -0,0 +1,532 @@
|
|
|
1
|
+
// 字段展示样式格式化:把字段值按设计态配置的展示样式码(display_style,权威目录在宿主后端)
|
|
2
|
+
// 转成展示文本。
|
|
3
|
+
//
|
|
4
|
+
// 定位:纯函数、零依赖、不读宿主状态、不做时区换算。供「不持有表格编辑器格式化引擎」的消费方复用——
|
|
5
|
+
// 例如模板历史记录列表的两侧实现(历史记录页插件与宿主内置回退视图),避免两份各写各的。
|
|
6
|
+
//
|
|
7
|
+
// 口径:逐档对齐表格编辑器的填报态单元格格式化。表格编辑器保留自有引擎(Excel 格式码全量实现),
|
|
8
|
+
// 两侧一致性由对拍测试钉住:任一侧改口径,对拍测试必须失败;新增样式码须两侧同步并补对拍矩阵。
|
|
9
|
+
//
|
|
10
|
+
// 与表格编辑器的刻意差异(均只扩展、不改变表格编辑器能处理的输入的结果):
|
|
11
|
+
// - 日期直接取字符串里的年月日时分秒分量,不经 Date 对象——浏览器所在时区若有夏令时空档,
|
|
12
|
+
// 经 Date 会把墙钟时刻平移一小时;业务日期字段是墙钟语义。
|
|
13
|
+
// - 额外接受带毫秒与时区后缀(Z / ±hh:mm)的 ISO 串,按字面墙钟分量取数、不做换算
|
|
14
|
+
// (与候选值格式化同一口径)。
|
|
15
|
+
// - 不接受 Excel 序列数与纯时间串(表格编辑器单元格存储形态,记录接口不会下发),返回 null 交调用方回退。
|
|
16
|
+
//
|
|
17
|
+
// 「自定义」日期时间样式(440)没有固定写法,格式串由调用方从字段 format_rule_json 读出
|
|
18
|
+
// (readDatetimePattern)后经 options.datetimePattern 传入;格式串的解析 / 渲染 / 粒度 / Excel 换算
|
|
19
|
+
// 见下方「自定义格式串」一节。放在同一文件而不另拆模块:本文件会被个别消费方单独编译成 JS
|
|
20
|
+
// 供 node 测试直接加载,单文件零相对导入才不受 ESM 扩展名解析影响。
|
|
21
|
+
|
|
22
|
+
// ── 自定义格式串(展示样式 440)────────────────────────────────────────────────
|
|
23
|
+
//
|
|
24
|
+
// 格式串的解析、校验、渲染、填报选择器粒度推断与 Excel numFmt 换算,从根入口导出。
|
|
25
|
+
// 平台各侧(宿主后端、表格编辑器、本 SDK)各有一份同口径实现,靠同一组用例做一致性测试——改口径须各侧同步。
|
|
26
|
+
//
|
|
27
|
+
// 约定:
|
|
28
|
+
// - 展示样式码 CUSTOM_DATETIME_DISPLAY_STYLE('440')表示「自定义」,只对 datetime 字段有意义;
|
|
29
|
+
// 格式串存在字段 format_rule_json 的 `datetime_pattern` 键,写入时保留其他键。
|
|
30
|
+
// - 记号(最长匹配优先):yyyy yy MM M dd d HH H mm m ss s;大写 M 是月、小写 m 是分。
|
|
31
|
+
// 单引号内为原样文字('' 表示一个单引号);其他字符原样输出。
|
|
32
|
+
// - 合法格式串:去首尾空白后 1~64 个字符,且至少含一个记号;非法时渲染返回 null,调用方回退原值显示。
|
|
33
|
+
// - 值一律按墙上时间(存储串 `yyyy-MM-dd HH:mm:ss` 的各分量)渲染,不做时区换算。
|
|
34
|
+
|
|
35
|
+
/** 「自定义」日期时间展示样式码。 */
|
|
36
|
+
export const CUSTOM_DATETIME_DISPLAY_STYLE = '440';
|
|
37
|
+
/** 格式串最大长度(按字符计,去首尾空白后)。 */
|
|
38
|
+
export const DATETIME_PATTERN_MAX_LENGTH = 64;
|
|
39
|
+
/** format_rule_json 中存放格式串的键。 */
|
|
40
|
+
export const DATETIME_PATTERN_KEY = 'datetime_pattern';
|
|
41
|
+
|
|
42
|
+
/** 格式串记号。 */
|
|
43
|
+
export type DatetimePatternToken = 'yyyy' | 'yy' | 'MM' | 'M' | 'dd' | 'd' | 'HH' | 'H' | 'mm' | 'm' | 'ss' | 's';
|
|
44
|
+
/** 格式串片段:记号或原样文字。 */
|
|
45
|
+
export type DatetimePatternPart = { kind: 'token'; token: DatetimePatternToken } | { kind: 'text'; text: string };
|
|
46
|
+
/** 填报选择器粒度(对齐现行五档:年 / 年月 / 日期 / 日期时间 / 时间)。 */
|
|
47
|
+
export type DatetimePatternGrain = 'year' | 'year-month' | 'date' | 'datetime' | 'time';
|
|
48
|
+
/** 格式串校验错误:空 / 超长 / 不含任何记号。 */
|
|
49
|
+
export type DatetimePatternError = 'empty' | 'too_long' | 'no_token';
|
|
50
|
+
|
|
51
|
+
// 最长匹配优先:同一字母的双写记号排在单写前面。
|
|
52
|
+
const TOKENS: DatetimePatternToken[] = ['yyyy', 'yy', 'MM', 'M', 'dd', 'd', 'HH', 'H', 'mm', 'm', 'ss', 's'];
|
|
53
|
+
|
|
54
|
+
/** 把格式串切成记号与原样文字两类片段(相邻文字合并)。 */
|
|
55
|
+
export function parseDatetimePattern(pattern: string): DatetimePatternPart[] {
|
|
56
|
+
const parts: DatetimePatternPart[] = [];
|
|
57
|
+
const pushText = (text: string): void => {
|
|
58
|
+
if (!text) return;
|
|
59
|
+
const last = parts[parts.length - 1];
|
|
60
|
+
if (last && last.kind === 'text') last.text += text;
|
|
61
|
+
else parts.push({ kind: 'text', text });
|
|
62
|
+
};
|
|
63
|
+
let i = 0;
|
|
64
|
+
while (i < pattern.length) {
|
|
65
|
+
const ch = pattern[i];
|
|
66
|
+
if (ch === "'") {
|
|
67
|
+
// '' → 一个单引号;'abc' → 原样文字(未闭合时读到结尾)
|
|
68
|
+
if (pattern[i + 1] === "'") {
|
|
69
|
+
pushText("'");
|
|
70
|
+
i += 2;
|
|
71
|
+
continue;
|
|
72
|
+
}
|
|
73
|
+
let j = i + 1;
|
|
74
|
+
let text = '';
|
|
75
|
+
while (j < pattern.length) {
|
|
76
|
+
if (pattern[j] === "'") {
|
|
77
|
+
if (pattern[j + 1] === "'") {
|
|
78
|
+
text += "'";
|
|
79
|
+
j += 2;
|
|
80
|
+
continue;
|
|
81
|
+
}
|
|
82
|
+
break;
|
|
83
|
+
}
|
|
84
|
+
text += pattern[j];
|
|
85
|
+
j += 1;
|
|
86
|
+
}
|
|
87
|
+
pushText(text);
|
|
88
|
+
i = j + 1;
|
|
89
|
+
continue;
|
|
90
|
+
}
|
|
91
|
+
const token = TOKENS.find((t) => pattern.startsWith(t, i));
|
|
92
|
+
if (token) {
|
|
93
|
+
parts.push({ kind: 'token', token });
|
|
94
|
+
i += token.length;
|
|
95
|
+
continue;
|
|
96
|
+
}
|
|
97
|
+
pushText(ch!);
|
|
98
|
+
i += 1;
|
|
99
|
+
}
|
|
100
|
+
return parts;
|
|
101
|
+
}
|
|
102
|
+
|
|
103
|
+
/** 校验格式串;合法返回 null。 */
|
|
104
|
+
export function validateDatetimePattern(pattern: string | null | undefined): DatetimePatternError | null {
|
|
105
|
+
const text = (pattern ?? '').trim();
|
|
106
|
+
if (!text) return 'empty';
|
|
107
|
+
if ([...text].length > DATETIME_PATTERN_MAX_LENGTH) return 'too_long';
|
|
108
|
+
if (!parseDatetimePattern(text).some((part) => part.kind === 'token')) return 'no_token';
|
|
109
|
+
return null;
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
/** 墙上时间分量(月份 1~12)。 */
|
|
113
|
+
export interface DatetimePatternWallClock {
|
|
114
|
+
year: number;
|
|
115
|
+
month: number;
|
|
116
|
+
day: number;
|
|
117
|
+
hour: number;
|
|
118
|
+
minute: number;
|
|
119
|
+
second: number;
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
/** 取 Date 在浏览器本地时区下的墙上时间分量(调用方自己决定 Date 的来源时区)。 */
|
|
123
|
+
function wallClockFromDate(date: Date): DatetimePatternWallClock {
|
|
124
|
+
return {
|
|
125
|
+
year: date.getFullYear(),
|
|
126
|
+
month: date.getMonth() + 1,
|
|
127
|
+
day: date.getDate(),
|
|
128
|
+
hour: date.getHours(),
|
|
129
|
+
minute: date.getMinutes(),
|
|
130
|
+
second: date.getSeconds(),
|
|
131
|
+
};
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
function tokenText(token: DatetimePatternToken, v: DatetimePatternWallClock): string {
|
|
135
|
+
switch (token) {
|
|
136
|
+
case 'yyyy': return String(v.year);
|
|
137
|
+
case 'yy': return pad2(v.year % 100);
|
|
138
|
+
case 'MM': return pad2(v.month);
|
|
139
|
+
case 'M': return String(v.month);
|
|
140
|
+
case 'dd': return pad2(v.day);
|
|
141
|
+
case 'd': return String(v.day);
|
|
142
|
+
case 'HH': return pad2(v.hour);
|
|
143
|
+
case 'H': return String(v.hour);
|
|
144
|
+
case 'mm': return pad2(v.minute);
|
|
145
|
+
case 'm': return String(v.minute);
|
|
146
|
+
case 'ss': return pad2(v.second);
|
|
147
|
+
case 's': return String(v.second);
|
|
148
|
+
}
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
/** 按格式串渲染墙上时间;格式串非法时返回 null(调用方回退原值显示)。 */
|
|
152
|
+
export function renderDatetimePattern(
|
|
153
|
+
pattern: string | null | undefined,
|
|
154
|
+
value: DatetimePatternWallClock | Date,
|
|
155
|
+
): string | null {
|
|
156
|
+
if (validateDatetimePattern(pattern) !== null) return null;
|
|
157
|
+
const v = value instanceof Date ? wallClockFromDate(value) : value;
|
|
158
|
+
return parseDatetimePattern((pattern ?? '').trim())
|
|
159
|
+
.map((part) => (part.kind === 'token' ? tokenText(part.token, v) : part.text))
|
|
160
|
+
.join('');
|
|
161
|
+
}
|
|
162
|
+
|
|
163
|
+
/** 按格式串里出现的记号推断填报选择器粒度(对齐现行五档);非法格式串按「日期 + 时间」处理。 */
|
|
164
|
+
export function datetimePatternGrain(pattern: string | null | undefined): DatetimePatternGrain {
|
|
165
|
+
if (validateDatetimePattern(pattern) !== null) return 'datetime';
|
|
166
|
+
const letters = new Set(
|
|
167
|
+
parseDatetimePattern((pattern ?? '').trim())
|
|
168
|
+
.filter((p): p is { kind: 'token'; token: DatetimePatternToken } => p.kind === 'token')
|
|
169
|
+
.map((p) => p.token[0]),
|
|
170
|
+
);
|
|
171
|
+
const hasDate = letters.has('y') || letters.has('M') || letters.has('d');
|
|
172
|
+
const hasTime = letters.has('H') || letters.has('m') || letters.has('s');
|
|
173
|
+
if (hasDate && hasTime) return 'datetime';
|
|
174
|
+
if (hasTime) return 'time';
|
|
175
|
+
if (letters.has('d')) return 'date';
|
|
176
|
+
if (letters.has('M')) return 'year-month';
|
|
177
|
+
return 'year';
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
const EXCEL_TOKEN: Record<DatetimePatternToken, string> = {
|
|
181
|
+
yyyy: 'yyyy', yy: 'yy', MM: 'mm', M: 'm', dd: 'dd', d: 'd', HH: 'hh', H: 'h', mm: 'mm', m: 'm', ss: 'ss', s: 's',
|
|
182
|
+
};
|
|
183
|
+
|
|
184
|
+
function excelLiteral(text: string): string {
|
|
185
|
+
// Excel numFmt:双引号内为原样文字,双引号本身用 \" 在引号外输出。
|
|
186
|
+
return text
|
|
187
|
+
.split('"')
|
|
188
|
+
.map((seg) => (seg ? `"${seg}"` : ''))
|
|
189
|
+
.join('\\"');
|
|
190
|
+
}
|
|
191
|
+
|
|
192
|
+
/**
|
|
193
|
+
* 换算为 Excel numFmt;Excel 会把「前一个记号是时或后一个记号是秒」的 m 判为分钟、其余判为月份,
|
|
194
|
+
* 若格式串里的月 / 分与 Excel 的判定不一致(如单独的「mm分」),返回空串,调用方改按格式化后的文本导出。
|
|
195
|
+
*/
|
|
196
|
+
export function datetimePatternToExcelNumFmt(pattern: string | null | undefined): string {
|
|
197
|
+
if (validateDatetimePattern(pattern) !== null) return '';
|
|
198
|
+
const parts = parseDatetimePattern((pattern ?? '').trim());
|
|
199
|
+
const tokens = parts
|
|
200
|
+
.filter((p): p is { kind: 'token'; token: DatetimePatternToken } => p.kind === 'token')
|
|
201
|
+
.map((p) => p.token);
|
|
202
|
+
for (let i = 0; i < tokens.length; i += 1) {
|
|
203
|
+
const t = tokens[i]!;
|
|
204
|
+
if (t[0] !== 'M' && t[0] !== 'm') continue;
|
|
205
|
+
const prev = tokens[i - 1];
|
|
206
|
+
const next = tokens[i + 1];
|
|
207
|
+
const excelMinute = (prev !== undefined && prev[0] === 'H') || (next !== undefined && next[0] === 's');
|
|
208
|
+
if (excelMinute !== (t[0] === 'm')) return '';
|
|
209
|
+
}
|
|
210
|
+
return parts.map((p) => (p.kind === 'token' ? EXCEL_TOKEN[p.token] : excelLiteral(p.text))).join('');
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
/** 从 format_rule_json(对象或 JSON 串)读格式串;没有则返回空串。 */
|
|
214
|
+
export function readDatetimePattern(formatRule: unknown): string {
|
|
215
|
+
let obj: unknown = formatRule;
|
|
216
|
+
if (typeof formatRule === 'string') {
|
|
217
|
+
if (!formatRule.trim()) return '';
|
|
218
|
+
try {
|
|
219
|
+
obj = JSON.parse(formatRule);
|
|
220
|
+
} catch {
|
|
221
|
+
return '';
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
if (!obj || typeof obj !== 'object' || Array.isArray(obj)) return '';
|
|
225
|
+
const value = (obj as Record<string, unknown>)[DATETIME_PATTERN_KEY];
|
|
226
|
+
return typeof value === 'string' ? value : '';
|
|
227
|
+
}
|
|
228
|
+
|
|
229
|
+
/** 写入格式串并保留 format_rule_json 的其他键;pattern 为空时移除该键。返回新对象。 */
|
|
230
|
+
export function writeDatetimePattern(formatRule: unknown, pattern: string): Record<string, unknown> {
|
|
231
|
+
let base: Record<string, unknown> = {};
|
|
232
|
+
let obj: unknown = formatRule;
|
|
233
|
+
if (typeof formatRule === 'string' && formatRule.trim()) {
|
|
234
|
+
try {
|
|
235
|
+
obj = JSON.parse(formatRule);
|
|
236
|
+
} catch {
|
|
237
|
+
obj = null;
|
|
238
|
+
}
|
|
239
|
+
}
|
|
240
|
+
if (obj && typeof obj === 'object' && !Array.isArray(obj)) base = { ...(obj as Record<string, unknown>) };
|
|
241
|
+
const text = pattern.trim();
|
|
242
|
+
if (text) base[DATETIME_PATTERN_KEY] = text;
|
|
243
|
+
else delete base[DATETIME_PATTERN_KEY];
|
|
244
|
+
return base;
|
|
245
|
+
}
|
|
246
|
+
|
|
247
|
+
/** 日期时间大类(目录大类「4」)叶子码。 */
|
|
248
|
+
const DATE_TIME_DISPLAY_STYLES = new Set<string>([
|
|
249
|
+
'401', '402', '403', '421', '404', '422', '405', '423', '412',
|
|
250
|
+
'406', '424', '407', '425', '408', '426', '413', '427', '414', '428', '415', '429',
|
|
251
|
+
'409', '430', '410', '431', '411', '432',
|
|
252
|
+
'416', '417', '418', '419',
|
|
253
|
+
// 「自定义」:按字段自己的格式串渲染
|
|
254
|
+
CUSTOM_DATETIME_DISPLAY_STYLE,
|
|
255
|
+
]);
|
|
256
|
+
|
|
257
|
+
/** formatDisplayStyleValue / formatDisplayStyleBucketLabel 的可选参数。 */
|
|
258
|
+
export interface DisplayStyleFormatOptions {
|
|
259
|
+
/**
|
|
260
|
+
* 「自定义」日期时间样式(440)的格式串,取自字段 format_rule_json.datetime_pattern
|
|
261
|
+
* (用 readDatetimePattern 读)。其他样式码忽略本参数;440 缺格式串或格式串非法时返回 null。
|
|
262
|
+
*/
|
|
263
|
+
datetimePattern?: string | null;
|
|
264
|
+
}
|
|
265
|
+
|
|
266
|
+
/** 数值样式渲染参数:小数位 / 千分位 / 前缀(货币符号)/ 是否百分比(值 ×100 加 %)。 */
|
|
267
|
+
interface NumericDisplayStyleSpec {
|
|
268
|
+
decimals: number;
|
|
269
|
+
thousand: boolean;
|
|
270
|
+
prefix: string;
|
|
271
|
+
percent: boolean;
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
/**
|
|
275
|
+
* 数值大类(目录大类「3」)叶子码 → 渲染参数。与表格编辑器数值样式映射的
|
|
276
|
+
* 单元格格式码逐档对应:301 `0` / 302 `0.00` / 304 `0.00%` / 308 `#,##0.00` / 306 `¥#,##0.00` / 307 `$#,##0.00`。
|
|
277
|
+
*/
|
|
278
|
+
const NUMERIC_DISPLAY_STYLE_SPECS: Record<string, NumericDisplayStyleSpec> = {
|
|
279
|
+
'301': { decimals: 0, thousand: false, prefix: '', percent: false },
|
|
280
|
+
'302': { decimals: 2, thousand: false, prefix: '', percent: false },
|
|
281
|
+
'304': { decimals: 2, thousand: false, prefix: '', percent: true },
|
|
282
|
+
'308': { decimals: 2, thousand: true, prefix: '', percent: false },
|
|
283
|
+
'306': { decimals: 2, thousand: true, prefix: '¥', percent: false },
|
|
284
|
+
'307': { decimals: 2, thousand: true, prefix: '$', percent: false },
|
|
285
|
+
};
|
|
286
|
+
|
|
287
|
+
/** 展示样式码是否属于日期时间大类。 */
|
|
288
|
+
export function isDateTimeDisplayStyle(displayStyle: string | null | undefined): boolean {
|
|
289
|
+
return !!displayStyle && DATE_TIME_DISPLAY_STYLES.has(displayStyle);
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
/** 展示样式码是否属于数值大类。 */
|
|
293
|
+
export function isNumericDisplayStyle(displayStyle: string | null | undefined): boolean {
|
|
294
|
+
return !!displayStyle && Object.prototype.hasOwnProperty.call(NUMERIC_DISPLAY_STYLE_SPECS, displayStyle);
|
|
295
|
+
}
|
|
296
|
+
|
|
297
|
+
/**
|
|
298
|
+
* 按展示样式码把字段值格式化为展示文本。
|
|
299
|
+
*
|
|
300
|
+
* 返回 null 表示「该样式没有格式化规则」(文本/图片/附件大类、未知码、空码)或「值解析不了」,
|
|
301
|
+
* 调用方应回退到自己原有的显示方式,不要把 null 当空文本呈现。
|
|
302
|
+
*/
|
|
303
|
+
export function formatDisplayStyleValue(
|
|
304
|
+
value: unknown,
|
|
305
|
+
displayStyle: string | null | undefined,
|
|
306
|
+
options?: DisplayStyleFormatOptions,
|
|
307
|
+
): string | null {
|
|
308
|
+
if (value === null || value === undefined || value === '') return null;
|
|
309
|
+
if (!displayStyle) return null;
|
|
310
|
+
if (DATE_TIME_DISPLAY_STYLES.has(displayStyle)) {
|
|
311
|
+
const parts = parseWallClockParts(value);
|
|
312
|
+
if (!parts) return null;
|
|
313
|
+
// 440 按墙钟分量套格式串;格式串缺失或非法时 renderDatetimePattern 返回 null,交调用方回退
|
|
314
|
+
if (displayStyle === CUSTOM_DATETIME_DISPLAY_STYLE) return renderDatetimePattern(options?.datetimePattern, parts);
|
|
315
|
+
return formatDateTimeParts(displayStyle, parts);
|
|
316
|
+
}
|
|
317
|
+
const spec = NUMERIC_DISPLAY_STYLE_SPECS[displayStyle];
|
|
318
|
+
if (spec) {
|
|
319
|
+
const numeric = coerceNumber(value);
|
|
320
|
+
return numeric === null ? null : formatNumber(numeric, spec);
|
|
321
|
+
}
|
|
322
|
+
return null;
|
|
323
|
+
}
|
|
324
|
+
|
|
325
|
+
// ── 数值 ────────────────────────────────────────────────────────────────────
|
|
326
|
+
|
|
327
|
+
/** 数值识别:有限数,或纯数字串(与表格编辑器的数值识别同一正则;千分位串 `1,234` 不认)。 */
|
|
328
|
+
function coerceNumber(value: unknown): number | null {
|
|
329
|
+
if (typeof value === 'number') return Number.isFinite(value) ? value : null;
|
|
330
|
+
if (typeof value !== 'string') return null;
|
|
331
|
+
const trimmed = value.trim();
|
|
332
|
+
if (!/^-?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/.test(trimmed)) return null;
|
|
333
|
+
const n = Number(trimmed);
|
|
334
|
+
return Number.isFinite(n) ? n : null;
|
|
335
|
+
}
|
|
336
|
+
|
|
337
|
+
/** 负号置于货币符号之前(`-¥1,234.50`),与表格编辑器一致;舍入沿用 toFixed(与表格编辑器同源)。 */
|
|
338
|
+
function formatNumber(value: number, spec: NumericDisplayStyleSpec): string {
|
|
339
|
+
const scaled = spec.percent ? value * 100 : value;
|
|
340
|
+
const body = renderFixedNumber(Math.abs(scaled), spec.decimals, spec.thousand);
|
|
341
|
+
const sign = value < 0 ? '-' : '';
|
|
342
|
+
return `${sign}${spec.prefix}${body}${spec.percent ? '%' : ''}`;
|
|
343
|
+
}
|
|
344
|
+
|
|
345
|
+
function renderFixedNumber(value: number, decimals: number, thousand: boolean): string {
|
|
346
|
+
if (!Number.isFinite(value)) return String(value);
|
|
347
|
+
const fixed = value.toFixed(decimals);
|
|
348
|
+
if (!thousand) return fixed;
|
|
349
|
+
const [intPart, decPart] = fixed.split('.');
|
|
350
|
+
const grouped = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
|
|
351
|
+
return decPart ? `${grouped}.${decPart}` : grouped;
|
|
352
|
+
}
|
|
353
|
+
|
|
354
|
+
// ── 日期时间 ────────────────────────────────────────────────────────────────
|
|
355
|
+
|
|
356
|
+
interface WallClockParts {
|
|
357
|
+
year: number;
|
|
358
|
+
month: number;
|
|
359
|
+
day: number;
|
|
360
|
+
hour: number;
|
|
361
|
+
minute: number;
|
|
362
|
+
second: number;
|
|
363
|
+
}
|
|
364
|
+
|
|
365
|
+
/**
|
|
366
|
+
* 解析 `YYYY-MM-DD`、`YYYY-MM-DD HH:mm`、`YYYY-MM-DD HH:mm:ss`(分隔符可为空格或 T),
|
|
367
|
+
* 可带毫秒与时区后缀(后缀只丢弃、不换算)。分量越界返回 null。
|
|
368
|
+
*/
|
|
369
|
+
function parseWallClockParts(value: unknown): WallClockParts | null {
|
|
370
|
+
if (typeof value !== 'string') return null;
|
|
371
|
+
const match = /^(\d{4})-(\d{2})-(\d{2})(?:[ T](\d{2}):(\d{2})(?::(\d{2})(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/.exec(value.trim());
|
|
372
|
+
if (!match) return null;
|
|
373
|
+
const parts: WallClockParts = {
|
|
374
|
+
year: Number(match[1]),
|
|
375
|
+
month: Number(match[2]),
|
|
376
|
+
day: Number(match[3]),
|
|
377
|
+
hour: Number(match[4] ?? 0),
|
|
378
|
+
minute: Number(match[5] ?? 0),
|
|
379
|
+
second: Number(match[6] ?? 0),
|
|
380
|
+
};
|
|
381
|
+
if (parts.month < 1 || parts.month > 12 || parts.day < 1 || parts.day > 31) return null;
|
|
382
|
+
if (parts.hour > 23 || parts.minute > 59 || parts.second > 59) return null;
|
|
383
|
+
return parts;
|
|
384
|
+
}
|
|
385
|
+
|
|
386
|
+
function pad2(value: number): string {
|
|
387
|
+
return String(value).padStart(2, '0');
|
|
388
|
+
}
|
|
389
|
+
|
|
390
|
+
/**
|
|
391
|
+
* 叶子码 → 文本,逐档对齐表格编辑器的主表字段样式预览:小时不补零、分秒补零。
|
|
392
|
+
* 中文纪年档(402/405/408/411… 等)是目录固定的数据格式,四语言一致,故直接写字面量。
|
|
393
|
+
*/
|
|
394
|
+
function formatDateTimeParts(displayStyle: string, parts: WallClockParts): string | null {
|
|
395
|
+
const { year, month, day, hour } = parts;
|
|
396
|
+
const minute = pad2(parts.minute);
|
|
397
|
+
const second = pad2(parts.second);
|
|
398
|
+
const mm = pad2(month);
|
|
399
|
+
const dd = pad2(day);
|
|
400
|
+
switch (displayStyle) {
|
|
401
|
+
case '401': return `${year}`;
|
|
402
|
+
case '402': return `${year}年`;
|
|
403
|
+
case '403': return `${year}-${month}`;
|
|
404
|
+
case '421': return `${year}-${mm}`;
|
|
405
|
+
case '404': return `${year}/${month}`;
|
|
406
|
+
case '422': return `${year}/${mm}`;
|
|
407
|
+
case '405': return `${year}年${month}月`;
|
|
408
|
+
case '423': return `${year}年${mm}月`;
|
|
409
|
+
case '412': return `${month}月`;
|
|
410
|
+
case '406': return `${year}-${month}-${day}`;
|
|
411
|
+
case '424': return `${year}-${mm}-${dd}`;
|
|
412
|
+
case '407': return `${year}/${month}/${day}`;
|
|
413
|
+
case '425': return `${year}/${mm}/${dd}`;
|
|
414
|
+
case '408': return `${year}年${month}月${day}日`;
|
|
415
|
+
case '426': return `${year}年${mm}月${dd}日`;
|
|
416
|
+
case '413': return `${month}-${day}`;
|
|
417
|
+
case '427': return `${mm}-${dd}`;
|
|
418
|
+
case '414': return `${month}/${day}`;
|
|
419
|
+
case '428': return `${mm}/${dd}`;
|
|
420
|
+
case '415': return `${month}月${day}日`;
|
|
421
|
+
case '429': return `${mm}月${dd}日`;
|
|
422
|
+
case '409': return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
|
|
423
|
+
case '430': return `${year}-${mm}-${dd} ${hour}:${minute}:${second}`;
|
|
424
|
+
case '410': return `${year}/${month}/${day} ${hour}:${minute}:${second}`;
|
|
425
|
+
case '431': return `${year}/${mm}/${dd} ${hour}:${minute}:${second}`;
|
|
426
|
+
case '411': return `${year}年${month}月${day}日 ${hour}时${minute}分${second}秒`;
|
|
427
|
+
case '432': return `${year}年${mm}月${dd}日 ${hour}时${minute}分${second}秒`;
|
|
428
|
+
case '416': return `${hour}:${minute}`;
|
|
429
|
+
case '417': return `${hour}时${minute}分`;
|
|
430
|
+
case '418': return `${hour}:${minute}:${second}`;
|
|
431
|
+
case '419': return `${hour}时${minute}分${second}秒`;
|
|
432
|
+
default: return null;
|
|
433
|
+
}
|
|
434
|
+
}
|
|
435
|
+
|
|
436
|
+
// ── 分组桶标签 ─────────────────────────────────────────────────────────────
|
|
437
|
+
|
|
438
|
+
/** 分组桶:日期桶(按年/月/日截断)或数值区间桶(含起不含止)。 */
|
|
439
|
+
export type DisplayStyleBucket =
|
|
440
|
+
| { kind: 'date'; granularity: 'year' | 'month' | 'day'; start: string }
|
|
441
|
+
| { kind: 'range'; start: number; end: number };
|
|
442
|
+
|
|
443
|
+
/**
|
|
444
|
+
* 把分组桶按字段展示样式格式化为分类树标签。
|
|
445
|
+
* - 日期桶:start 取 `YYYY-MM-DD...`(或 RFC3339)的字面年月日,不经 Date、不换算时区;
|
|
446
|
+
* 按样式码的日期写法(中文年月日 / 斜杠 / 短横线)截到所选粒度,如 `2026年10月`、`2026/10`、`2026-10`。
|
|
447
|
+
* 样式码不是日期类、或该写法无法截到所选粒度的写法推断 → 返回 null,调用方回退到自己的显示方式。
|
|
448
|
+
* - 数值区间桶:两端各按数值样式格式化,用 ` ~ ` 连接;非数值样式两端原样数字连接。
|
|
449
|
+
*/
|
|
450
|
+
export function formatDisplayStyleBucketLabel(
|
|
451
|
+
bucket: DisplayStyleBucket,
|
|
452
|
+
displayStyle: string | null | undefined,
|
|
453
|
+
options?: DisplayStyleFormatOptions,
|
|
454
|
+
): string | null {
|
|
455
|
+
if (bucket.kind === 'range') {
|
|
456
|
+
if (!Number.isFinite(bucket.start) || !Number.isFinite(bucket.end)) return null;
|
|
457
|
+
const fmt = (n: number): string =>
|
|
458
|
+
(isNumericDisplayStyle(displayStyle) ? formatDisplayStyleValue(n, displayStyle) : null) ?? String(n);
|
|
459
|
+
return `${fmt(bucket.start)} ~ ${fmt(bucket.end)}`;
|
|
460
|
+
}
|
|
461
|
+
if (!displayStyle || !DATE_TIME_DISPLAY_STYLES.has(displayStyle)) return null;
|
|
462
|
+
const parts = parseWallClockParts(bucket.start);
|
|
463
|
+
if (!parts) return null;
|
|
464
|
+
const custom = displayStyle === CUSTOM_DATETIME_DISPLAY_STYLE ? customDateBucketStyle(options?.datetimePattern) : null;
|
|
465
|
+
if (displayStyle === CUSTOM_DATETIME_DISPLAY_STYLE && !custom) return null;
|
|
466
|
+
const sep = custom ? custom.sep : dateSeparatorOf(displayStyle);
|
|
467
|
+
if (!sep) return null;
|
|
468
|
+
// 补零口径跟随样式本身:421~432 族补零,401~411 族不补零(对齐 formatDateTimeParts);
|
|
469
|
+
// 440 看格式串里月 / 日用的是双写(MM、dd)还是单写
|
|
470
|
+
const padded = custom ? custom.padded : PADDED_DATE_STYLES.has(displayStyle);
|
|
471
|
+
const mm = padded ? pad2(parts.month) : String(parts.month);
|
|
472
|
+
const dd = padded ? pad2(parts.day) : String(parts.day);
|
|
473
|
+
if (sep === 'cn') {
|
|
474
|
+
if (bucket.granularity === 'year') return `${parts.year}年`;
|
|
475
|
+
if (bucket.granularity === 'month') return `${parts.year}年${mm}月`;
|
|
476
|
+
return `${parts.year}年${mm}月${dd}日`;
|
|
477
|
+
}
|
|
478
|
+
if (bucket.granularity === 'year') return `${parts.year}`;
|
|
479
|
+
if (bucket.granularity === 'month') return `${parts.year}${sep}${mm}`;
|
|
480
|
+
return `${parts.year}${sep}${mm}${sep}${dd}`;
|
|
481
|
+
}
|
|
482
|
+
|
|
483
|
+
/**
|
|
484
|
+
* 「自定义」格式串 → 分组桶标签的写法。分组桶要求标签无歧义、跨桶可比,所以不逐字套用格式串
|
|
485
|
+
* (格式串可能缺年份、用两位年、把日放在月前),而是按格式串推断与固定日期样式同一套的写法:
|
|
486
|
+
* - 写法:格式串的原样文字里出现「年」→ 中文年月日;否则取第一个夹在两个日期记号(y/M/d)之间的
|
|
487
|
+
* 分隔文字,是 `/` 或 `.` 就用它,其余一律按短横线;
|
|
488
|
+
* - 补零:格式串里出现 MM 或 dd 双写记号即补零;
|
|
489
|
+
* - 年份一律四位、年在前,按所选粒度截断(与固定日期样式的桶标签同口径)。
|
|
490
|
+
* 格式串缺失 / 非法 / 不含任何日期记号(纯时间格式)→ null,调用方回退到自己的显示方式。
|
|
491
|
+
*/
|
|
492
|
+
function customDateBucketStyle(
|
|
493
|
+
pattern: string | null | undefined,
|
|
494
|
+
): { sep: '-' | '/' | '.' | 'cn'; padded: boolean } | null {
|
|
495
|
+
if (validateDatetimePattern(pattern) !== null) return null;
|
|
496
|
+
const parts = parseDatetimePattern((pattern ?? '').trim());
|
|
497
|
+
const isDateToken = (p: (typeof parts)[number] | undefined): boolean =>
|
|
498
|
+
!!p && p.kind === 'token' && (p.token[0] === 'y' || p.token[0] === 'M' || p.token[0] === 'd');
|
|
499
|
+
if (!parts.some((p) => isDateToken(p))) return null;
|
|
500
|
+
const padded = parts.some((p) => p.kind === 'token' && (p.token === 'MM' || p.token === 'dd'));
|
|
501
|
+
if (parts.some((p) => p.kind === 'text' && p.text.includes('年'))) return { sep: 'cn', padded };
|
|
502
|
+
let sep: '-' | '/' | '.' = '-';
|
|
503
|
+
for (let i = 1; i < parts.length - 1; i += 1) {
|
|
504
|
+
const part = parts[i]!;
|
|
505
|
+
if (part.kind !== 'text' || !isDateToken(parts[i - 1]) || !isDateToken(parts[i + 1])) continue;
|
|
506
|
+
const text = part.text.trim();
|
|
507
|
+
if (text === '/' || text === '.') sep = text;
|
|
508
|
+
break;
|
|
509
|
+
}
|
|
510
|
+
return { sep, padded };
|
|
511
|
+
}
|
|
512
|
+
|
|
513
|
+
/** 月/日补零的日期样式码(421~432 族);其余日期码(401~411)不补零。 */
|
|
514
|
+
const PADDED_DATE_STYLES = new Set<string>(['421', '422', '423', '424', '425', '426', '430', '431', '432']);
|
|
515
|
+
|
|
516
|
+
/**
|
|
517
|
+
* 日期样式码 → 日期写法:'cn'=中文年月日、'/'=斜杠、'-'=短横线;时分秒类与纯月日类(缺年份)返回 null。
|
|
518
|
+
* 码表对应 formatDateTimeParts:401~403/406/409/421/424/430 为短横线(401 仅年份按短横线处理),
|
|
519
|
+
* 402/405/408/411/423/426/432 为中文,404/407/410/422/425/431 为斜杠。
|
|
520
|
+
*/
|
|
521
|
+
function dateSeparatorOf(displayStyle: string): '-' | '/' | 'cn' | null {
|
|
522
|
+
switch (displayStyle) {
|
|
523
|
+
case '401': case '403': case '421': case '406': case '424': case '409': case '430':
|
|
524
|
+
return '-';
|
|
525
|
+
case '404': case '422': case '407': case '425': case '410': case '431':
|
|
526
|
+
return '/';
|
|
527
|
+
case '402': case '405': case '423': case '408': case '426': case '411': case '432':
|
|
528
|
+
return 'cn';
|
|
529
|
+
default:
|
|
530
|
+
return null;
|
|
531
|
+
}
|
|
532
|
+
}
|