feat(phase-1): 京东数据库 UI 改造蓝图 Phase 1——类目计数聚合纯函数+首屏默认档 50

This commit is contained in:
2026-11-21 03:47:45 +08:00
parent 22771a7aea
commit 380792aa82
6 changed files with 242 additions and 11 deletions
@@ -153,3 +153,78 @@ export function jdCategoryNamesUnder(path: string[]): string[] | null {
walk([target])
return out
}
/** GET /categories 的计数行({name, productCount},name=京麦末级类目即落库
* category_path;同名末级在后端是同一等值桶,此处一行一名)。 */
export interface JdCategoryCountEntry {
name: string
productCount: number
}
/** 带计数的树节点:count=自身名+全部后代名(子树内去重)的 productCount 之和——
* 与「点节点 → jdCategoryNamesUnder 展开集合 IN 过滤」的命中集合同源(v1.6 蓝图
* Phase 1 备料):徽标数必须就是点它之后列表会命中的行数,两边各算各的就会出现
* 「徽标 5、点进去 8 行」。leaf/children 与 JdCategoryNode 同义(leaf=children 空)。 */
export interface JdCategoryCountedNode {
name: string
value: string
count: number
leaf: boolean
children: JdCategoryCountedNode[]
}
/** 计数聚合回执:roots=树形计数树(全部授权类目都在,无词条的节点 count=0);
* extra=树上任何节点名(含非叶)都对不上的历史行(树外兜底组——京麦改树后的
* 存量 category_path 从这里选,语义同旧版级联第三栏兜底)。 */
export interface JdCategoryCountTree {
roots: JdCategoryCountedNode[]
extra: JdCategoryCountEntry[]
/** 兜底组计数和(徽标直接用)。 */
extraTotal: number
}
/** /categories 计数行 → 树形计数聚合(v1.6 蓝图 Phase 1)。同名跨支叶(短裤/唐装/
* 吊带/背心/赠品)按过滤语义如实计入两个分支——点哪个分支都按同一名字等值命中
* 同一批行,不是双计;父层子树内按名字去重求和(与展开集合口径一致,父层徽标
* 不因同名跨支翻倍)。名字对不上树上任何节点的行归树外兜底组。脏值归一:空名
* 跳过、计数非有限数归 0、负数钳 0、同名多行求和。 */
export function jdCategoryCountTree(entries: JdCategoryCountEntry[]): JdCategoryCountTree {
const counts = new Map<string, number>()
for (const entry of Array.isArray(entries) ? entries : []) {
const name = entry && typeof entry.name === 'string' ? entry.name.trim() : ''
if (!name) continue
const raw = entry.productCount
const value = typeof raw === 'number' && Number.isFinite(raw) ? Math.max(0, Math.floor(raw)) : 0
counts.set(name, (counts.get(name) ?? 0) + value)
}
const treeNames = new Set<string>()
const build = (
nodes: JdCategoryNode[],
): { out: JdCategoryCountedNode[]; names: Set<string> } => {
const out: JdCategoryCountedNode[] = []
const names = new Set<string>()
for (const node of nodes) {
treeNames.add(node.name)
const child =
node.children && node.children.length
? build(node.children)
: { out: [] as JdCategoryCountedNode[], names: new Set<string>() }
const set = new Set(child.names)
set.add(node.name)
let count = 0
for (const name of set) count += counts.get(name) ?? 0
out.push({ name: node.name, value: node.value, count, leaf: child.out.length === 0, children: child.out })
for (const name of set) names.add(name)
}
return { out, names }
}
const roots = build(JD_CATEGORY_TREE).out
const extra: JdCategoryCountEntry[] = []
let extraTotal = 0
for (const [name, count] of counts) {
if (treeNames.has(name)) continue
extra.push({ name, productCount: count })
extraTotal += count
}
return { roots, extra, extraTotal }
}
@@ -1,5 +1,5 @@
/** 京东数据库页筛选纯函数(v1.4 Phase 5):商品编码/标题关键字/类目/分组/同步起止 + snake 分页参数。
* 产出与后端契约 §列表 query 逐字对撞:`page`/`page_size`(默认 20、上限 100)、
* 产出与后端契约 §列表 query 逐字对撞:`page`/`page_size`(默认 50、上限 100)、
* `product_code`、`title_keyword`、`category`(京麦末级类目等值过滤,2026-11-15 增)、
* `group_id`(当前分组下的分类 id)、`owner_group_id`(当前数据权限分组,V203)、
* `synced_from`/`synced_to`(ISO yyyy-MM-dd;空白不下发)。
@@ -15,9 +15,14 @@
import { validIsoDateOrUndefined } from '../asin/asin-filter.ts'
import { jdCategoryNamesUnder } from './jd-category-tree.ts'
/** 每页条数默认 20(v1.4 §3.4),上限 100。 */
export const JD_PRODUCT_PAGE_SIZE = 20
/** 每页条数默认 50(v1.6 蓝图 Phase 1 新契约,商城款式一屏 50),上限 100。
* v1.4 §3.4 的默认 20 由 2026-11-21 蓝图拍板放宽;页面装配层 ref(20) 的旧硬编码
* 随 Phase 5 重写改挂本常量,纯函数层先把新契约钉住。 */
export const JD_PRODUCT_PAGE_SIZE = 50
export const JD_PRODUCT_MAX_PAGE_SIZE = 100
/** 每页条数档位(v1.6 新契约 20/50/100):页面装配层的档位选择器从这里取数,
* 不再各写各的字面量(Phase 5 接线;旧全局 OldPagination 默认档 10/20/50/100 不动)。 */
export const JD_PRODUCT_PAGE_SIZE_OPTIONS = [20, 50, 100] as const
/** 页码上限:与后端 MAX_PAGE(CR-18 先例,外观专利同值)对齐,两侧不漂。 */
export const JD_PRODUCT_MAX_PAGE = 10_000
/** 分类状态快筛的出厂档位(2026-11-17 用户口径「不需要全部分类 默认卡在未分类上就行」):
@@ -48,8 +48,8 @@ export interface JdProductPageResult {
pageSize: number
}
/** 前端首屏默认容量(与 filter 侧 JD_PRODUCT_PAGE_SIZE 同值 20)。 */
export const JD_PRODUCT_DEFAULT_SIZE = 20
/** 前端首屏默认容量(与 filter 侧 JD_PRODUCT_PAGE_SIZE 同值 50,v1.6 蓝图 Phase 1 新契约)。 */
export const JD_PRODUCT_DEFAULT_SIZE = 50
export function emptyJdProductPage(): JdProductPageResult {
return { items: [], total: 0, page: 1, pageSize: JD_PRODUCT_DEFAULT_SIZE }
@@ -1,8 +1,8 @@
{
"note": "readSource 钉子逐文件基线。两把尺子:pins=落在用例体内的读盘,reads=全文读点总数(含模块级夹具与 helper)。都只许减;pins 下降而 reads 没同步下降=把读盘挪出体内,不算改进。由 tests/source-pin-ratchet.test.ts 生成。",
"totals": {
"files": 263,
"cases": 1847,
"files": 264,
"cases": 1857,
"pins": 460,
"reads": 658
},
@@ -192,6 +192,11 @@
"pins": 0,
"reads": 0
},
"batch-delete.test.ts": {
"cases": 3,
"pins": 0,
"reads": 0
},
"brand-gating-model.test.ts": {
"cases": 5,
"pins": 0,
@@ -308,7 +313,7 @@
"reads": 0
},
"jd-category-tree.test.ts": {
"cases": 8,
"cases": 14,
"pins": 0,
"reads": 0
},
@@ -318,7 +323,7 @@
"reads": 0
},
"jd-product-group.test.ts": {
"cases": 7,
"cases": 8,
"pins": 0,
"reads": 0
},
@@ -4,11 +4,13 @@ import {
JD_CATEGORY_TREE,
jdCategoryAllNodes,
jdCategoryChildren,
jdCategoryCountTree,
jdCategoryLeaves,
jdCategoryNamesUnder,
jdCategoryRoots,
jdCategorySearchLeaves,
jdCategorySearchNodes,
type JdCategoryCountedNode,
} from '../src/pages/jd/jd-category-tree.ts'
/** 京麦授权类目真树(2026-11-16 真机取证 getVenderLicenseCategory 快照;与用户端
@@ -132,3 +134,132 @@ test('子树展开集合:含自身+全部后代名、去重、不越支;
const women = jdCategoryNamesUnder(['服饰内衣', '女装'])!
assert.equal(new Set(women).size, women.length, '展开集合内部去重')
})
/** v1.6 蓝图 Phase 1 备料:/categories 计数行 → 树形计数聚合(侧栏徽标的数据源)。 */
/** 按名称路径取计数节点(与 jdCategoryChildren 同构的测试侧寻路)。 */
const nodeAt = (roots: JdCategoryCountedNode[], path: string[]): JdCategoryCountedNode | null => {
let level = roots
let hit: JdCategoryCountedNode | null = null
for (const name of path) {
hit = level.find((node) => node.name === name) ?? null
if (!hit) return null
level = hit.children
}
return hit
}
test('计数聚合——节点徽标=自身名+子树叶和,与 jdCategoryNamesUnder 展开集合同源', () => {
const tree = jdCategoryCountTree([
{ name: '艺考形体服', productCount: 5 },
{ name: '啦啦队服', productCount: 3 },
{ name: '拉丁舞服', productCount: 2 },
{ name: '连衣裙', productCount: 7 },
{ name: '短袖连衣裙', productCount: 4 },
])
assert.equal(tree.extra.length, 0, '树内名字不进兜底组')
assert.equal(tree.extraTotal, 0)
const roots = tree.roots
assert.equal(roots.length, 3, '一级节点全量保留(无词条的一级也在)')
assert.deepEqual(
roots.map((node) => node.name),
['服饰内衣', '母婴', '运动户外'],
)
assert.equal(roots.find((node) => node.name === '母婴')!.count, 0, '无词条的一级归 0 不缺节点')
const sport = nodeAt(roots, ['运动户外'])!
assert.equal(sport.count, 10, '运动户外=艺考5+啦啦3+拉丁2')
assert.equal(sport.leaf, false)
const dance = nodeAt(roots, ['运动户外', '舞蹈体操鞋服/装备'])!
assert.equal(dance.count, 10, '二级下钻同和')
const yikao = nodeAt(roots, ['运动户外', '舞蹈体操鞋服/装备', '艺考形体服'])!
assert.equal(yikao.count, 5, '末级叶子=该名计数')
assert.equal(yikao.leaf, true, 'children 空=末级')
assert.deepEqual(yikao.children, [], '叶子 children 是空数组(UI 直接遍历不炸)')
const dress = nodeAt(roots, ['服饰内衣', '女装', '连衣裙'])!
assert.equal(dress.count, 11, '连衣裙=自身名7+短袖4(长袖/无袖无词条归 0)')
assert.equal(nodeAt(roots, ['服饰内衣', '女装'])!.count, 11, '女装只有连衣裙支有词条')
assert.equal(roots.find((node) => node.name === '服饰内衣')!.count, 11, '一级汇总到根')
const dressLeaves = nodeAt(roots, ['服饰内衣', '女装', '连衣裙'])!.children.map((node) => node.name)
assert.deepEqual(dressLeaves, ['短袖连衣裙', '长袖连衣裙', '无袖连衣裙'], '子节点形状与静态树逐字同')
})
test('计数聚合——父级名本身是落库末级名:计入自身节点(快照层级可能比实际浅)', () => {
const tree = jdCategoryCountTree([
{ name: '女装', productCount: 6 },
{ name: '短袖连衣裙', productCount: 1 },
])
const roots = tree.roots
assert.equal(nodeAt(roots, ['服饰内衣', '女装'])!.count, 7, '女装徽标=自身6+子树1')
assert.equal(roots.find((node) => node.name === '服饰内衣')!.count, 7)
assert.equal(tree.extra.length, 0, '非叶名也是合法落库名,不进兜底组')
})
test('计数聚合——同名跨支叶:两个分支都计入(点哪支都等值命中同一批行),父层去重不翻倍', () => {
const tree = jdCategoryCountTree([{ name: '短裤', productCount: 9 }])
const roots = tree.roots
assert.equal(nodeAt(roots, ['服饰内衣', '女装'])!.count, 9, '女装支的短裤叶如实计入')
assert.equal(nodeAt(roots, ['服饰内衣', '男装'])!.count, 9, '男装支的同名叶同计数(过滤语义非双计)')
assert.equal(roots.find((node) => node.name === '服饰内衣')!.count, 9,
'父层子树按名字去重求和:展开集合里短裤只出现一次,徽标不得翻倍成 18')
assert.equal(tree.extra.length, 0)
})
test('计数聚合——树外兜底组:树上任何节点名都对不上的历史行单独归组', () => {
const tree = jdCategoryCountTree([
{ name: '已下架历史类目', productCount: 12 },
{ name: '另一个树外名', productCount: 8 },
{ name: '艺考形体服', productCount: 5 },
])
assert.deepEqual(
tree.extra.map((row) => row.name),
['已下架历史类目', '另一个树外名'],
'兜底组按入参顺序保留',
)
assert.deepEqual(
tree.extra.map((row) => row.productCount),
[12, 8],
)
assert.equal(tree.extraTotal, 20, '兜底组和=徽标直接用')
const sport = nodeAt(tree.roots, ['运动户外', '舞蹈体操鞋服/装备', '艺考形体服'])!
assert.equal(sport.count, 5, '树内行照常聚合,兜底不影响树形')
})
test('计数聚合——脏值归一:空名跳过、非有限/负数归 0、前后空白截掉、同名多行求和', () => {
const tree = jdCategoryCountTree([
{ name: '', productCount: 5 },
{ name: ' ', productCount: 7 },
{ name: '短裤', productCount: Number.NaN },
{ name: '唐装', productCount: -3 },
{ name: ' 女装 ', productCount: 2 },
{ name: '女装', productCount: 3 },
{ name: '艺考形体服', productCount: '4' as unknown as number },
] as { name: string; productCount: number }[])
const roots = tree.roots
assert.equal(nodeAt(roots, ['服饰内衣', '女装'])!.count, 5, 'trim 后同名求和 2+3')
assert.equal(nodeAt(roots, ['服饰内衣', '男装'])!.count, 0, 'NaN/负数/空名都归 0 不记账')
assert.equal(tree.extra.length, 0, '空名词条不进兜底组')
assert.equal(tree.extraTotal, 0)
})
test('计数聚合——空输入:全树 0、兜底组空(结构仍完整可渲染)', () => {
const tree = jdCategoryCountTree([])
assert.equal(tree.roots.length, 3)
assert.equal(tree.extra.length, 0)
assert.equal(tree.extraTotal, 0)
const total = tree.roots.reduce((sum, node) => sum + node.count, 0)
assert.equal(total, 0)
// 结构与静态树同形:一级孩子数与 jdCategoryChildren 逐一对齐。
for (const root of tree.roots) {
assert.deepEqual(
root.children.map((node) => node.name),
jdCategoryChildren([root.name]).map((node) => node.name),
)
}
// 非数组入参按空处理(运行期 resilience,JS 调用方传 null 不炸)。
const junk = jdCategoryCountTree(null as unknown as [])
assert.equal(junk.roots.length, 3)
assert.equal(junk.extraTotal, 0)
})
@@ -5,7 +5,8 @@
* 本文件只 import 被测纯函数。
*
* 覆盖:
* 1. **snake 参数形状**:toJdProductListParams 产出 `page`/`page_size`(默认 20、上限 100)、
* 1. **snake 参数形状**:toJdProductListParams 产出 `page`/`page_size`(默认 50、上限 100、
* 档位 20/50/100〔v1.6 蓝图 Phase 1 新契约〕)、
* `product_code`/`title_keyword`/`group_id`/`owner_group_id`/`synced_from`/`synced_to`
* (ISO yyyy-MM-dd;空白不下发;groupId 空串→不带、有值→snake group_id;ownerGroupId>0 才带、
* 0/null/NaN 一律不带=后端按作用域默认分组取,V203);分页钳制(铁律 15)。
@@ -21,6 +22,9 @@ import assert from 'node:assert/strict'
import {
JD_PRODUCT_MAX_PAGE,
JD_PRODUCT_MAX_PAGE_SIZE,
JD_PRODUCT_PAGE_SIZE,
JD_PRODUCT_PAGE_SIZE_OPTIONS,
createJdProductFilterState,
toJdProductListParams,
} from '../src/pages/jd/jd-product-filter.ts'
@@ -29,6 +33,7 @@ import {
jdCategoryRoots,
} from '../src/pages/jd/jd-category-tree.ts'
import {
JD_PRODUCT_DEFAULT_SIZE,
jdPriceRange,
parseJdProductDetail,
parseJdProductPage,
@@ -99,7 +104,7 @@ test('京东列表参数——snake 形状:groupId 空→不带、有值→gro
test('京东列表参数——page 钳制防 (page-1)*page_size 溢出(铁律 15)', () => {
const low = toJdProductListParams(createJdProductFilterState(), 0, 0)
assert.equal(low.page, 1, 'page<1 归 1')
assert.equal(low.page_size, 20, 'page_size 非法回默认 20')
assert.equal(low.page_size, 50, 'page_size 非法回默认 50(v1.6 新契约)')
const big = toJdProductListParams(createJdProductFilterState(), 3, 500)
assert.equal(big.page_size, 100, 'page_size 上限 100')
@@ -110,6 +115,16 @@ test('京东列表参数——page 钳制防 (page-1)*page_size 溢出(铁律
assert.equal(offset, 999_900)
})
/** v1.6 蓝图 Phase 1 新契约:首屏默认 50、档位 20/50/100;model 侧默认与 filter 侧
* 同值不漂(页面装配层 Phase 5 改挂常量,两处字面量从此只剩常量出处)。 */
test('分页档位——默认 50、档位 20/50/100、上限 100 不放宽', () => {
assert.deepEqual([...JD_PRODUCT_PAGE_SIZE_OPTIONS], [20, 50, 100], '档位清单逐字同(新契约)')
assert.ok(JD_PRODUCT_PAGE_SIZE_OPTIONS.includes(JD_PRODUCT_PAGE_SIZE), '默认值必须是档位之一')
assert.equal(JD_PRODUCT_PAGE_SIZE, 50, '默认档 50(v1.6 拍板放宽,v1.4 §3.4 的 20 已废)')
assert.equal(JD_PRODUCT_DEFAULT_SIZE, JD_PRODUCT_PAGE_SIZE, 'model 侧默认与 filter 侧同值')
assert.equal(JD_PRODUCT_MAX_PAGE_SIZE, 100, '上限 100 不放宽(后端 CR-18 同值)')
})
/** 分类状态快筛(2026-11-17 用户口径「加个已分类和未分类的筛选」,同日定默认卡未分类;
* 2026-11-18 用户口径「加个全部选项」恢复全量档):界面三档,'classified'→true、
* 'ungrouped'→false、''(全部)→ 不带 classified 参数;出厂默认与「重置」仍卡 ungrouped。