@fish-under-sea/magpie-dragonapi 0.2.1 → 0.3.0

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.
@@ -0,0 +1,458 @@
1
+ // 把「分组 × 模型」的行聚合成「一个模型一张卡」。
2
+ //
3
+ // 站点把同一个模型在 14 个分组里各卖一份,目录因此是「分组 × 模型」的行表
4
+ // (189 行 / 125 个模型)。用户要找的是「有没有这个模型、大概什么价」,
5
+ // 所以展示层要反过来:一个模型一张卡,把它的全部分组都列出来。
6
+ //
7
+ // 这里只做纯计算,不碰 DOM —— 这样能直接单测,也避免渲染逻辑里藏聚合规则。
8
+ //
9
+ // 约束:
10
+ // - 不省略任何分组。分组少就一行排开,多就换行,绝不出现「+3」。
11
+ // - 价格给区间而不是「取最低」:不同分组价差很大(0.06× 到 1.2×),
12
+ // 只显示一个数会让人以为那就是这个模型的价。
13
+ // - 计价方式不一致(例如有的分组按倍率、有的按次)时标成 mixed,不假装统一。
14
+
15
+ /** 分组排序:有倍率的按倍率升序,auto / 无倍率的排后面,同倍率按分组名。 */
16
+ function byRatioThenName(a, b) {
17
+ const ra = typeof a.ratio === 'number' && a.ratio > 0 ? a.ratio : Infinity
18
+ const rb = typeof b.ratio === 'number' && b.ratio > 0 ? b.ratio : Infinity
19
+ if (ra !== rb) return ra - rb
20
+ return String(a.id || '').localeCompare(String(b.id || ''), 'zh')
21
+ }
22
+
23
+ /**
24
+ * 一列数值(每百万 token 的单价)在多个分组之间的区间。
25
+ * 没有任何有限数值时返回 null —— 调用方据此退回站点给的字符串。
26
+ */
27
+ export function spanOf(groups, key) {
28
+ const nums = []
29
+ for (const g of groups) {
30
+ const n = g && g.pricing ? g.pricing[key] : null
31
+ if (typeof n === 'number' && Number.isFinite(n)) nums.push(n)
32
+ }
33
+ if (!nums.length) return null
34
+ const min = Math.min(...nums)
35
+ const max = Math.max(...nums)
36
+ return { min, max, same: min === max, count: nums.length }
37
+ }
38
+
39
+ /** 计价方式:全部分组一致就用那个;不一致标 mixed;全都没有就 unknown。 */
40
+ function kindOfGroups(groups) {
41
+ const kinds = new Set()
42
+ for (const g of groups) {
43
+ if (g.auto) { kinds.add('auto'); continue }
44
+ kinds.add((g.pricing && g.pricing.kind) || 'unknown')
45
+ }
46
+ if (!kinds.size) return 'unknown'
47
+ if (kinds.size === 1) return [...kinds][0]
48
+ return kinds.has('unknown') && kinds.size === 1 ? 'unknown' : 'mixed'
49
+ }
50
+
51
+ /**
52
+ * 模型名里的版本号:`gpt-6.1-sol` → [6,1],`deepseek-v4` → [4]。
53
+ * 取第一段数字串,`-` 与 `.` 都当分隔(站点两种写法混用)。
54
+ */
55
+ export function versionRank(name) {
56
+ const m = String(name || '').match(/\d+(?:[.-]\d+)*/)
57
+ return m ? m[0].split(/[.-]/).map(Number) : null
58
+ }
59
+
60
+ /**
61
+ * 模型等级词:数值越小等级越高。想调整顺序只改这张表。
62
+ *
63
+ * Anthropic 的等级就是代号,顺序是 **fable > opus > sonnet > haiku**(f-o-s-h)。
64
+ * 这类代号不带版本号,必须单独列出,否则它们会全落进默认档、按名字排——
65
+ * 那样 haiku 会排在 opus 前面,fable 也上不去。
66
+ *
67
+ * 其它厂商用档位词表达同一件事:max/ultra(旗舰)> pro/plus(进阶)>
68
+ * 默认(标准)> fast/flash/lite/mini(轻量)> draft(草稿)。
69
+ * 等级只在**同一厂商内**比较,所以两套词放一张表不会互相干扰。
70
+ */
71
+ const TIER_WORDS = {
72
+ fable: 0,
73
+ opus: 1, max: 1, ultra: 1, quality: 1, best: 1,
74
+ sonnet: 2, pro: 2, plus: 2, prime: 2, advanced: 2,
75
+ // 3 = 标准档(没有档位词时的默认,见 TIER_DEFAULT)
76
+ fast: 4, flash: 4, flashx: 4, lite: 4, light: 4, mini: 4, turbo: 4, highspeed: 4,
77
+ haiku: 4,
78
+ draft: 5,
79
+ }
80
+ const TIER_DEFAULT = 3
81
+
82
+ /**
83
+ * 厂商自有的代号等级:**按顺序匹配,先命中先用**,所以越具体的写越前。
84
+ *
85
+ * 一些厂商不用档位词,而是用一串代号表示等级。这种顺序只能由人定,
86
+ * 写在这里比塞进通用词表清楚——通用词表跨厂商共用,加进去会误伤别家。
87
+ *
88
+ * Google:`gemini-4-carbon`(c) > `gemini-4-argon`(a) > `argon-high`(a-h)
89
+ * > `argon-medium`(a-m) > `argon-low`(a-l) > `flash`。
90
+ */
91
+ const VENDOR_GRADES = {
92
+ Google: [
93
+ [/carbon/i, 0],
94
+ [/argon-h(?:igh)?\b/i, 2],
95
+ [/argon-m(?:edium)?\b/i, 3],
96
+ [/argon-l(?:ow)?\b/i, 4],
97
+ [/\bargon\b/i, 1],
98
+ [/flash/i, 5],
99
+ ],
100
+ OpenAI: [
101
+ // GPT 的代号等级:astra(a) > sol > terra。等级优先于代数,所以
102
+ // gpt-6-astra 排在 gpt-6.1-sol 前面——代数只在同一道内比较。
103
+ [/\bastra\b/i, 0],
104
+ [/\bsol\b/i, 1],
105
+ [/\bterra\b/i, 2],
106
+ // codex 是另一条产品线(代码审查),不该和对话型号插花排,
107
+ // 单独排在这些等级之后。
108
+ [/\bcodex\b/i, 4],
109
+ ],
110
+ }
111
+
112
+ /** 取名字里**从最高档开始**的档位词;整词匹配,避免 `minimax` 命中 `mini`。 */
113
+ export function tierRankOf(name, vendor = '') {
114
+ const vendorRules = VENDOR_GRADES[vendor]
115
+ if (Array.isArray(vendorRules)) {
116
+ for (const [re, rank] of vendorRules) if (re.test(String(name || ''))) return rank
117
+ }
118
+
119
+ const tokens = String(name || '').toLowerCase().split(/[-_.\s]+/).filter(Boolean)
120
+ let best = null
121
+ for (const t of tokens) {
122
+ const r = TIER_WORDS[t]
123
+ if (r !== undefined && (best === null || r < best)) best = r
124
+ }
125
+ return best === null ? TIER_DEFAULT : best
126
+ }
127
+
128
+ /**
129
+ * 国模的品牌顺序:kimi → ds → qwen → glm → hy → minimax → mimo。
130
+ *
131
+ * 目录里的 vendor 字段不统一(Moonshot / DeepSeek / 智谱 / 阿里云 / 阿里巴巴,
132
+ * 还有空的),而混元 hy、小米 mimo 常常连 vendor 都是空的,所以品牌只能
133
+ * 从「名字 + vendor」一起判。没列到的品牌排在后面,按名字排。
134
+ */
135
+ const BRAND_ORDER = ['kimi', 'ds', 'qwen', 'glm', 'hy', 'minimax', 'mimo']
136
+ const BRAND_TESTS = [
137
+ ['kimi', /\bkimi\b|moonshot|月之暗面/i],
138
+ ['ds', /deepseek/i],
139
+ ['qwen', /\bqwen\b|通义|千问|阿里/i],
140
+ ['glm', /\bglm\b|智谱|zhipu/i],
141
+ ['hy', /\bhy\d|\bhy\b|混元|hunyuan/i],
142
+ // h3 是 MiniMax 的海螺 3(视频),**必须排在 minimax 之前**:
143
+ // 否则 `minimax-h3` 会先命中 /minimax/ 被判成 minimax 品牌,
144
+ // 于是它在视频顺序里找不到位置、被排到最后。
145
+ ['h3', /\bh3\b|hailuo/i],
146
+ ['minimax', /minimax|海螺/i],
147
+ ['mimo', /\bmimo\b|小米|xiaomi/i],
148
+ // 图片 / 视频这两类各自有厂商顺序(见 CATEGORY_BRAND_ORDER),
149
+ // 先把它们的品牌认出来,排序时按类别查表。
150
+ ['seed', /seedance/i],
151
+ ['h3', /\bh3\b|hailuo-?3/i],
152
+ ['wan', /wan\d|wan-video|万相/i],
153
+ ['veo', /\bveo\b/i],
154
+ ['omni', /\bomni\b/i],
155
+ ['muse', /\bmuse\b/i],
156
+ ['grok', /grok/i],
157
+ ['gpt-image', /gpt-image/i],
158
+ ['gemini-image', /gemini.*image|nano-?banana|^banana/i],
159
+ ]
160
+
161
+ /**
162
+ * 类别专用的品牌顺序。站点的模型页按「厂商」分区,而每个类别里的厂商
163
+ * 谁先谁后是业务判断,只能一类一类定:
164
+ * - 国模:见 BRAND_ORDER(kimi → ds → qwen → glm → hy → minimax → mimo)
165
+ * - 视频:seed(ance) → h3 → wan → veo → omni → grok → muse
166
+ */
167
+ const CATEGORY_BRAND_ORDER = {
168
+ video: ['seed', 'h3', 'wan', 'veo', 'omni', 'grok', 'muse'],
169
+ // 图片:OpenAI 的 gpt-image 先,其次 Google 的 gemini 图像系列
170
+ // (含 nano-banana / banana),最后 xAI 的 grok-imagine-image。
171
+ image: ['gpt-image', 'gemini-image', 'grok'],
172
+ }
173
+
174
+ /**
175
+ * 品牌 id:**先按名字判,再看 vendor**。
176
+ *
177
+ * 顺序不能反:`wan3.0-video` 的 vendor 是「阿里云」,而阿里云在 qwen 的规则里,
178
+ * 先看 vendor 会把它判成 qwen,于是视频区里的 wan 找错了位置(排到最后)。
179
+ * 名字里写了什么厂商就是什么厂商,vendor 只在名字看不出来时兜底。
180
+ */
181
+ export function brandOf(name, vendor = '') {
182
+ const n = String(name || '')
183
+ for (const [id, re] of BRAND_TESTS) if (re.test(n)) return id
184
+ const v = String(vendor || '')
185
+ if (v) {
186
+ for (const [id, re] of BRAND_TESTS) if (re.test(v)) return id
187
+ }
188
+ return v
189
+ }
190
+
191
+ /** 等级优先于代数的类别(代号即等级的那几家);其余类别代数优先。 */
192
+ const GRADE_FIRST_CATS = new Set(['claude', 'gpt', 'gemini'])
193
+
194
+ /**
195
+ * 品牌排序权重:类别专用表优先(视频/图片),其次国模品牌表,
196
+ * 都没列到的排最后(按品牌名兜底)。
197
+ */
198
+ function brandRank(brand, cat) {
199
+ const local = CATEGORY_BRAND_ORDER[cat]
200
+ if (Array.isArray(local)) {
201
+ const i = local.indexOf(brand)
202
+ if (i >= 0) return i
203
+ }
204
+ const j = BRAND_ORDER.indexOf(brand)
205
+ return j < 0 ? 1000 : 100 + j
206
+ }
207
+
208
+ /** 只比版本号:返回负数表示 a 更新;版本相同返回 0(交给调用方继续比档位/名称)。 */
209
+ export function cmpVersionDesc(a, b) {
210
+ const x = versionRank(a.name)
211
+ const y = versionRank(b.name)
212
+ if (x && y) {
213
+ const n = Math.max(x.length, y.length)
214
+ for (let i = 0; i < n; i++) {
215
+ const d = (y[i] || 0) - (x[i] || 0)
216
+ if (d) return d
217
+ }
218
+ return 0
219
+ }
220
+ if (x) return -1
221
+ if (y) return 1
222
+ return 0
223
+ }
224
+
225
+ /** 版本从新到旧;没有版本号的排到本组末尾;同版本按名称。 */
226
+ export function byVersionDesc(a, b) {
227
+ return cmpVersionDesc(a, b) || String(a.name || '').localeCompare(String(b.name || ''), 'zh')
228
+ }
229
+
230
+ /**
231
+ * 默认排序:**厂商 → 等级分道 → 轮转取版本**。
232
+ *
233
+ * 不能只按「等级 → 版本」排成一片:那样 Claude 区会连着出现 fable-5-2、
234
+ * fable-5-1、fable-5 三张同等级卡,再轮到 opus 一大片。用户要的是
235
+ * 「每个等级轮流往下取一个版本」:
236
+ *
237
+ * f5.2 → o5.5 → s5.5 → h5.5 → f5.1 → o5.5 → s5 → …
238
+ *
239
+ * 所以不是比较器,而是「分道 + 轮转」:
240
+ * 1. 按类别(侧栏顺序)与厂商分桶,桶之间按类别顺序拼接;
241
+ * 2. 桶内按等级分道(fable / opus / sonnet / haiku …,即 TIER_WORDS 的档位);
242
+ * 3. 每道内部按版本从新到旧;
243
+ * 4. 各道按等级从高到低轮流取一个,取完为止。
244
+ *
245
+ * 只有一道时(例如 GPT 区几乎全在默认档),结果就是普通的版本降序。
246
+ */
247
+ export function orderDefault(aggs, { catOf, catOrder = [] } = {}) {
248
+ const list = Array.isArray(aggs) ? aggs : []
249
+ const catRank = (a) => {
250
+ const c = catOf ? catOf(a) : 'other'
251
+ const i = catOrder.indexOf(c)
252
+ return i < 0 ? catOrder.length : i
253
+ }
254
+
255
+ // 1. 分桶:类别 + 品牌。同一品牌可能散在多个 vendor 名下(阿里云 / 阿里巴巴
256
+ // 都卖 qwen),所以用品牌而不是 vendor 做桶键;空品牌排在本类别末尾。
257
+ const buckets = new Map()
258
+ for (const a of list) {
259
+ const rank = catRank(a)
260
+ const cat = catOf ? catOf(a) : 'other'
261
+ const brand = brandOf(a.name, a.vendor)
262
+ const key = `${rank}\u0000${brand}`
263
+ let b = buckets.get(key)
264
+ if (!b) {
265
+ b = { rank, cat, brand, items: [] }
266
+ buckets.set(key, b)
267
+ }
268
+ b.items.push(a)
269
+ }
270
+
271
+ const out = []
272
+ const orderedBuckets = [...buckets.values()]
273
+ .sort((x, y) => x.rank - y.rank
274
+ || brandRank(x.brand, x.cat) - brandRank(y.brand, y.cat)
275
+ || String(x.brand || '\uffff').localeCompare(String(y.brand || '\uffff'), 'zh'))
276
+
277
+ for (const bucket of orderedBuckets) {
278
+ // 两种排序语义,按类别分开:
279
+ // A. 代号即等级(Claude 的 f/o/s/h、GPT 的 astra/sol/terra、Gemini 的
280
+ // carbon/argon):等级优先于代数,分道轮转;
281
+ // B. 档位词只是同代变体(pro / flash / lite …,国模与图片视频都属于这种):
282
+ // 代数优先——2.6-flash 必须排在 2.5-pro 前面,同代内再比档位。
283
+ if (!GRADE_FIRST_CATS.has(bucket.cat)) {
284
+ // 顺序:版本 → 档位 → 名称。不能直接用 byVersionDesc,它在版本相同时
285
+ // 就用名字比了,会把「档位」这一层挡掉(glm-5-3-flash 会压住 glm-5.3)。
286
+ bucket.items.sort((a, b) => cmpVersionDesc(a, b)
287
+ || tierRankOf(a.name, a.vendor) - tierRankOf(b.name, a.vendor)
288
+ || String(a.name || '').localeCompare(String(b.name || ''), 'zh'))
289
+ out.push(...bucket.items)
290
+ continue
291
+ }
292
+
293
+ // A. 分道:等级 → 该等级的模型(道内按版本降序)
294
+ const lanes = new Map()
295
+ for (const a of bucket.items) {
296
+ const t = tierRankOf(a.name, a.vendor)
297
+ const lane = lanes.get(t) || []
298
+ lane.push(a)
299
+ lanes.set(t, lane)
300
+ }
301
+ const laneOrder = [...lanes.keys()].sort((x, y) => x - y)
302
+ for (const t of laneOrder) lanes.get(t).sort(byVersionDesc)
303
+
304
+ // 轮转:每轮各道取一个,直到取完
305
+ const cursor = new Map(laneOrder.map((t) => [t, 0]))
306
+ let remaining = bucket.items.length
307
+ while (remaining > 0) {
308
+ for (const t of laneOrder) {
309
+ const lane = lanes.get(t)
310
+ const i = cursor.get(t)
311
+ if (i >= lane.length) continue
312
+ out.push(lane[i])
313
+ cursor.set(t, i + 1)
314
+ remaining -= 1
315
+ }
316
+ }
317
+ }
318
+
319
+ return out
320
+ }
321
+ /**
322
+ * rows:目录里的行(每行一个分组×模型,字段见 lib/catalog.mjs 的 buildCatalog)。
323
+ * 返回聚合后的模型数组,每个元素带 groups(全部分组,按倍率升序)。
324
+ *
325
+ * 分组一律逐个列出,即使两个分组的倍率与价格完全一样也不合并:
326
+ * 分组名是用户要认的渠道,拼成 `gpt-pro/promax` 会让人以为那是一个名字。
327
+ * 分组多时自然换到第二行,这个双行排布是刻意的,卡片高度仍由预留高度取齐。
328
+ */
329
+ export function aggregateRows(rows) {
330
+ const map = new Map()
331
+
332
+ for (const r of Array.isArray(rows) ? rows : []) {
333
+ const name = r.name || r.id || ''
334
+ const key = name || `#${map.size}`
335
+ let a = map.get(key)
336
+
337
+ if (!a) {
338
+ a = {
339
+ key,
340
+ name,
341
+ id: r.id || '',
342
+ vendor: r.vendor || '',
343
+ kind: r.kind || 'chat',
344
+ context: r.context ?? null,
345
+ description: r.description || '',
346
+ tags: r.tags || '',
347
+ endpoints: Array.isArray(r.endpoints) ? [...r.endpoints] : [],
348
+ groups: [],
349
+ }
350
+ map.set(key, a)
351
+ }
352
+
353
+ // 同一模型的元信息偶有缺项(不同分组的行补全程度不同),补最全的那个。
354
+ if (!a.description && r.description) a.description = r.description
355
+ if (a.context == null && r.context != null) a.context = r.context
356
+ if (!a.vendor && r.vendor) a.vendor = r.vendor
357
+ if (!a.tags && r.tags) a.tags = r.tags
358
+ for (const e of Array.isArray(r.endpoints) ? r.endpoints : []) {
359
+ if (!a.endpoints.includes(e)) a.endpoints.push(e)
360
+ }
361
+
362
+ a.groups.push({
363
+ id: r.group || '',
364
+ ratio: typeof r.groupRatio === 'number' ? r.groupRatio : null,
365
+ auto: r.group === 'auto' || r.groupAuto === true,
366
+ pricing: r.pricing || {},
367
+ row: r,
368
+ })
369
+ }
370
+
371
+ const out = [...map.values()]
372
+ for (const a of out) {
373
+ a.groups.sort(byRatioThenName)
374
+ a.cheapest = a.groups[0] || null
375
+ a.priceKind = kindOfGroups(a.groups)
376
+ a.prices = {
377
+ input: spanOf(a.groups, 'inputNum'),
378
+ output: spanOf(a.groups, 'outputNum'),
379
+ cache: spanOf(a.groups, 'cacheNum'),
380
+ }
381
+ a.groupCount = a.groups.length
382
+ }
383
+
384
+ // 输出顺序保持输入首见顺序,调用方的排序菜单仍掌握最终顺序。
385
+ return mergeAliases(out)
386
+ }
387
+
388
+ /** 版本号里的 `-` 与 `.` 视为同一种写法:claude-opus-5-5 ≡ claude-opus-5.5。 */
389
+ function canonicalName(name) {
390
+ return String(name || '').replace(/(\d)-(?=\d)/g, '$1.')
391
+ }
392
+
393
+ /** 两个分组项是不是同一个「槽位」:同分组、同倍率、同计价、三档数值一致。 */
394
+ function sameSlot(a, b) {
395
+ const pa = a.pricing || {}
396
+ const pb = b.pricing || {}
397
+ return a.id === b.id
398
+ && (a.ratio ?? null) === (b.ratio ?? null)
399
+ && (pa.kind || '') === (pb.kind || '')
400
+ && (pa.inputNum ?? null) === (pb.inputNum ?? null)
401
+ && (pa.outputNum ?? null) === (pb.outputNum ?? null)
402
+ && (pa.cacheNum ?? null) === (pb.cacheNum ?? null)
403
+ }
404
+
405
+ /**
406
+ * 合并同一模型的不同拼写(`claude-opus-5-5` 与 `claude-opus-5.5`)。
407
+ *
408
+ * 站点把同一个模型按两种写法挂在目录里,不合并就会多出一张看起来重复的卡。
409
+ * 但「名字长得像」不能当作等价证据,所以加一道硬门槛:**较短的变体**的每个
410
+ * 分组,都必须在**较长的变体**里找到同分组、同倍率、同计价、三档数值完全一样
411
+ * 的一项;全部对上才合并,否则保持两张。合并时只保留主名,另一边记进 aliases,
412
+ * 详情页会写出来,不会悄悄消失。
413
+ */
414
+ function mergeAliases(aggs) {
415
+ const buckets = new Map()
416
+ for (const a of aggs) {
417
+ const k = canonicalName(a.name)
418
+ const list = buckets.get(k) || []
419
+ list.push(a)
420
+ buckets.set(k, list)
421
+ }
422
+
423
+ const out = []
424
+ for (const list of buckets.values()) {
425
+ if (list.length === 1) { out.push(list[0]); continue }
426
+ // 分组更全的那个当主名(用户看到的名字)
427
+ list.sort((x, y) => y.groupCount - x.groupCount || String(x.name).localeCompare(String(y.name), 'zh'))
428
+ const primary = list[0]
429
+ primary.aliases = [primary.name]
430
+ for (const v of list.slice(1)) {
431
+ const covered = v.groups.every((gv) => primary.groups.some((gp) => sameSlot(gv, gp)))
432
+ if (!covered) {
433
+ // 证据不足:当作不同模型,各自保留
434
+ out.push(v)
435
+ continue
436
+ }
437
+ if (!primary.aliases.includes(v.name)) primary.aliases.push(v.name)
438
+ }
439
+ out.push(primary)
440
+ }
441
+ // 保持调用方拿到的顺序稳定:按首次出现重排
442
+ const order = new Map(aggs.map((a, i) => [a, i]))
443
+ out.sort((x, y) => (order.get(x) ?? 0) - (order.get(y) ?? 0))
444
+ return out
445
+ }
446
+
447
+ /**
448
+ * 选一个「聚焦分组」:筛选了某个分组就选它,否则选最便宜的。
449
+ * 详情页的价签、倍率与「当前」标记都以它为准。
450
+ */
451
+ export function focusGroupOf(agg, preferGroupId) {
452
+ if (!agg || !Array.isArray(agg.groups) || !agg.groups.length) return null
453
+ if (preferGroupId) {
454
+ const hit = agg.groups.find((g) => g.id === preferGroupId)
455
+ if (hit) return hit
456
+ }
457
+ return agg.cheapest || agg.groups[0]
458
+ }