Skip to content

Commit 9e86da1

Browse files
committed
Update @types/unist
1 parent b63722b commit 9e86da1

File tree

2 files changed

+58
-47
lines changed

2 files changed

+58
-47
lines changed

package.json

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -38,19 +38,20 @@
3838
"index.js"
3939
],
4040
"dependencies": {
41-
"@types/unist": "^2.0.0",
42-
"unist-util-is": "^5.0.0",
43-
"unist-util-visit-parents": "^5.0.0"
41+
"@types/unist": "^3.0.0",
42+
"unist-util-is": "^6.0.0",
43+
"unist-util-visit-parents": "^6.0.0"
4444
},
4545
"devDependencies": {
46+
"@types/mdast": "^4.0.0",
4647
"@types/node": "^20.0.0",
4748
"c8": "^8.0.0",
4849
"prettier": "^2.0.0",
4950
"remark-cli": "^11.0.0",
5051
"remark-preset-wooorm": "^9.0.0",
5152
"type-coverage": "^2.0.0",
5253
"typescript": "^5.0.0",
53-
"unist-builder": "^3.0.0",
54+
"unist-builder": "^4.0.0",
5455
"xo": "^0.54.0"
5556
},
5657
"scripts": {

test.js

Lines changed: 53 additions & 43 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
/**
2-
* @typedef {import('unist').Literal<string>} Literal
2+
* @typedef {import('mdast').Text} Text
3+
* @typedef {import('mdast').Emphasis} Emphasis
4+
* @typedef {import('mdast').Root} Root
35
* @typedef {import('unist').Node} Node
46
*/
57

@@ -16,24 +18,26 @@ test('remove', async function (t) {
1618
})
1719

1820
await t.test('should compare nodes by partial properties', function () {
19-
const leaf1 = u('leaf', '1')
20-
const leaf2 = u('leaf', '2')
21+
const leaf1 = u('text', '1')
22+
const leaf2 = u('text', '2')
2123
const children = [leaf1, leaf2]
22-
const tree = u('node', children)
24+
/** @type {Emphasis} */
25+
const tree = u('emphasis', children)
2326

2427
const next = remove(tree, {value: '2'})
2528

26-
assert.deepEqual(tree, u('node', [leaf1]))
29+
assert.deepEqual(tree, u('emphasis', [leaf1]))
2730
assert.equal(next, tree)
2831
assert.equal(next.children, children)
2932
assert.equal(next.children[0], leaf1)
3033
})
3134

3235
await t.test('should remove parent nodes', function () {
33-
const leaf1 = u('leaf', '1')
34-
const leaf2 = u('leaf', '2')
35-
const parent = u('parent', [leaf1])
36+
const leaf1 = u('text', '1')
37+
const leaf2 = u('text', '2')
38+
const parent = u('emphasis', [leaf1])
3639
const children = [parent, leaf2]
40+
/** @type {Root} */
3741
const tree = u('root', children)
3842

3943
const next = remove(tree, test)
@@ -55,103 +59,109 @@ test('remove', async function (t) {
5559
await t.test(
5660
'should return `undefined` if root node is removed',
5761
function () {
58-
const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
62+
/** @type {Root} */
63+
const tree = u('root', [u('emphasis', [u('text', '1')]), u('text', '2')])
5964
const next = remove(tree, 'root')
6065

6166
assert.equal(next, undefined)
6267
}
6368
)
6469

6570
await t.test('should cascade (remove) root nodes', function () {
66-
const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
67-
const next = remove(tree, 'leaf')
71+
/** @type {Root} */
72+
const tree = u('root', [u('emphasis', [u('text', '1')]), u('text', '2')])
73+
const next = remove(tree, 'text')
6874

6975
assert.equal(next, undefined)
7076
})
7177

7278
await t.test(
7379
'should not cascade (remove) nodes that were empty initially',
7480
function () {
75-
const tree = u('node', [u('node', []), u('node', [u('leaf')])])
81+
/** @type {Root} */
82+
const tree = u('root', [
83+
u('emphasis', []),
84+
u('emphasis', [u('text', 'x')])
85+
])
7686

77-
remove(tree, 'leaf')
87+
remove(tree, 'text')
7888

79-
assert.deepEqual(tree, u('node', [u('node', [])]))
89+
assert.deepEqual(tree, u('root', [u('emphasis', [])]))
8090
}
8191
)
8292

8393
await t.test('should support type tests', function () {
84-
const tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
94+
/** @type {Root} */
95+
const tree = u('root', [u('emphasis', [u('text', '1')]), u('text', '2')])
8596

86-
remove(tree, {cascade: false}, 'leaf')
97+
remove(tree, {cascade: false}, 'text')
8798

88-
assert.deepEqual(tree, u('node', [u('node', [])]))
99+
assert.deepEqual(tree, u('root', [u('emphasis', [])]))
89100
})
90101

91102
await t.test('should support function tests', function () {
92-
const tree = u('node', [u('node', [u('leaf', '1')]), u('leaf', '2')])
103+
/** @type {Emphasis} */
104+
const tree = u('emphasis', [
105+
u('emphasis', [u('text', '1')]),
106+
u('text', '2')
107+
])
93108

94109
remove(tree, {cascade: false}, test)
95110

96-
assert.deepEqual(tree, u('node', [u('node', []), u('leaf', '2')]))
111+
assert.deepEqual(tree, u('emphasis', [u('emphasis', []), u('text', '2')]))
97112

98113
/**
99114
* @param {Node} node
100115
* @returns {boolean}
101116
*/
102117
function test(node) {
103-
return literal(node) && node.value === '1'
118+
return node.type === 'text' && 'value' in node && node.value === '1'
104119
}
105120
})
106121

107122
await t.test('should support `cascade = true`', function () {
108-
const tree = u('root', [u('node', [u('leaf', '1')]), u('leaf', '2')])
109-
const next = remove(tree, {cascade: true}, 'leaf')
123+
/** @type {Root} */
124+
const tree = u('root', [u('emphasis', [u('text', '1')]), u('text', '2')])
125+
const next = remove(tree, {cascade: true}, 'text')
110126

111127
assert.equal(next, undefined)
112128
})
113129

114130
await t.test('should support `cascade = false`', function () {
115-
const leaf1 = u('leaf', '1')
116-
const leaf2 = u('leaf', '2')
131+
const leaf1 = u('text', '1')
132+
const leaf2 = u('text', '2')
117133
const nodeChildren = [leaf1]
118-
const node = u('node', nodeChildren)
134+
const node = u('emphasis', nodeChildren)
119135
const siblings = [node, leaf2]
136+
/** @type {Root} */
120137
const tree = u('root', siblings)
121138

122-
const next = remove(tree, {cascade: false}, 'leaf')
139+
const next = remove(tree, {cascade: false}, 'text')
123140

124-
assert.deepEqual(tree, u('root', [u('node', [])]))
141+
assert.deepEqual(tree, u('root', [u('emphasis', [])]))
125142
assert.equal(next, tree)
126143
assert.equal(next.children, siblings)
127144
assert.equal(next.children[0], node)
128145
assert.equal(next.children[0].children, nodeChildren)
129146
})
130147

131148
await t.test('should support the example from readme', function () {
149+
/** @type {Root} */
132150
const tree = u('root', [
133-
u('leaf', '1'),
134-
u('node', [
135-
u('leaf', '2'),
136-
u('node', [u('leaf', '3'), u('other', '4')]),
137-
u('node', [u('leaf', '5')])
151+
u('text', '1'),
152+
u('emphasis', [
153+
u('text', '2'),
154+
u('emphasis', [u('text', '3'), u('inlineCode', '4')]),
155+
u('emphasis', [u('text', '5')])
138156
]),
139-
u('leaf', '6')
157+
u('text', '6')
140158
])
141159

142-
remove(tree, 'leaf')
160+
remove(tree, 'text')
143161

144162
assert.deepEqual(
145163
tree,
146-
u('root', [u('node', [u('node', [u('other', '4')])])])
164+
u('root', [u('emphasis', [u('emphasis', [u('inlineCode', '4')])])])
147165
)
148166
})
149167
})
150-
151-
/**
152-
* @param {Node} node
153-
* @returns {node is Literal}
154-
*/
155-
function literal(node) {
156-
return 'value' in node
157-
}

0 commit comments

Comments
 (0)