Skip to content

Commit 7fde0e9

Browse files
sinclairzx81sinclairzx81
committed
updates
1 parent 383e854 commit 7fde0e9

File tree

3 files changed

+227
-5
lines changed

3 files changed

+227
-5
lines changed

‎example/index.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@
22

33
import { Token } from '@sinclair/parsebox'
44

5-
const R = Token.BigInt(' 123_123n hello world I am here')
5+
const R = Token.Const(' ', ' ')
66

77
console.log(R)
88

‎src/token/const.ts‎

Lines changed: 35 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -28,16 +28,47 @@ THE SOFTWARE.
2828

2929
// deno-fmt-ignore-file
3030

31+
import { Guard } from '../guard/index.ts'
32+
33+
import { IsResult } from './internal/result.ts'
34+
import { type TTrimWhitespace, TrimWhitespace } from './internal/trim.ts'
3135
import { type TTrim, Trim } from './internal/trim.ts'
3236
import { type TTake, Take } from './internal/take.ts'
3337

38+
import { type TNewLine, NewLine } from './internal/char.ts'
39+
import { type TWhiteSpace, WhiteSpace } from './internal/char.ts'
40+
41+
// ------------------------------------------------------------------
42+
// TakeConst
43+
// ------------------------------------------------------------------
44+
type TTakeConst<Input extends string, Const extends string> = (
45+
TTake<Input, [Const]>
46+
)
47+
function TakeConst<Input extends string, Const extends string>(input: Input, const_: Const): TTakeConst<Input, Const> {
48+
return Take(input, [const_]) as never
49+
}
50+
// ------------------------------------------------------------------
51+
// Const
52+
// ------------------------------------------------------------------
3453
/** Matches if next is the given Const value */
35-
export type TConst<Input extends string, Const extends string, Trimmed extends string = TTrim<Input>> = (
36-
TTake<Trimmed, [Const]>
54+
export type TConst<Input extends string, Const extends string> = (
55+
Const extends '' ? ['', Input] :
56+
Const extends `${infer First extends string}${string}` ? (
57+
First extends TNewLine ? TTakeConst<TTrimWhitespace<Input>, Const> :
58+
First extends TWhiteSpace ? TTakeConst<Input, Const> :
59+
TTakeConst<TTrim<Input>, Const>
60+
) : []
3761
)
3862
/** Matches if next is the given Const value */
3963
export function Const<Input extends string, Const extends string>(input: Input, const_: Const): TConst<Input, Const> {
40-
const trimmed = Trim(input)
41-
return Take(trimmed, [const_]) as never
64+
return (
65+
Guard.IsEqual(const_, '') ? ['', input] : (() => {
66+
return (
67+
input.startsWith(NewLine) ? TakeConst(TrimWhitespace(input), const_) :
68+
input.startsWith(WhiteSpace) ? TakeConst(input, const_) :
69+
TakeConst(Trim(input), const_)
70+
)
71+
})()
72+
) as never
4273
}
4374

‎test/parsebox/token/const.ts‎

Lines changed: 191 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,191 @@
1+
import { Token } from '@sinclair/parsebox'
2+
import { Assert } from 'test'
3+
4+
const Test = Assert.Context('Token.Const')
5+
6+
// ------------------------------------------------------------------
7+
// Const: Empty
8+
// ------------------------------------------------------------------
9+
Test('Should Const 1', () => {
10+
const R: ['', ''] = Token.Const('', '')
11+
Assert.IsEqual(R, ['', ''])
12+
})
13+
Test('Should Const 2', () => {
14+
const R: ['', 'A'] = Token.Const('A', '')
15+
Assert.IsEqual(R, ['', 'A'])
16+
})
17+
Test('Should Const 3', () => {
18+
const R: ['', ' A'] = Token.Const(' A', '')
19+
Assert.IsEqual(R, ['', ' A'])
20+
})
21+
// ------------------------------------------------------------------
22+
// Const: Single-Whitespace
23+
// ------------------------------------------------------------------
24+
Test('Should Const Single-Whitespace 1', () => {
25+
const R: [] = Token.Const('', ' ')
26+
Assert.IsEqual(R, [])
27+
})
28+
Test('Should Const Single-Whitespace 2', () => {
29+
const R: [' ', ''] = Token.Const(' ', ' ')
30+
Assert.IsEqual(R, [' ', ''])
31+
})
32+
Test('Should Const Single-Whitespace 3', () => {
33+
const R: [' ', 'A'] = Token.Const(' A', ' ')
34+
Assert.IsEqual(R, [' ', 'A'])
35+
})
36+
Test('Should Const Single-Whitespace 4', () => {
37+
const R: [' ', 'A '] = Token.Const(' A ', ' ')
38+
Assert.IsEqual(R, [' ', 'A '])
39+
})
40+
Test('Should Const Single-Whitespace 5', () => {
41+
const R: [' ', 'AA'] = Token.Const(' AA', ' ')
42+
Assert.IsEqual(R, [' ', 'AA'])
43+
})
44+
Test('Should Const Single-Whitespace 6', () => {
45+
const R: [' ', 'AA '] = Token.Const(' AA ', ' ')
46+
Assert.IsEqual(R, [' ', 'AA '])
47+
})
48+
49+
// ------------------------------------------------------------------
50+
// Const: Multi-Whitespace
51+
// ------------------------------------------------------------------
52+
Test('Should Const Multi-Whitespace 1', () => {
53+
const R: [] = Token.Const('', ' ')
54+
Assert.IsEqual(R, [])
55+
})
56+
Test('Should Const Multi-Whitespace 2', () => {
57+
const R: [] = Token.Const(' ', ' ')
58+
Assert.IsEqual(R, [])
59+
})
60+
Test('Should Const Multi-Whitespace 3', () => {
61+
const R: [' ', 'A'] = Token.Const(' A', ' ')
62+
Assert.IsEqual(R, [' ', 'A'])
63+
})
64+
Test('Should Const Multi-Whitespace 4', () => {
65+
const R: [' ', 'A '] = Token.Const(' A ', ' ')
66+
Assert.IsEqual(R, [' ', 'A '])
67+
})
68+
Test('Should Const Multi-Whitespace 5', () => {
69+
const R: [' ', 'AA'] = Token.Const(' AA', ' ')
70+
Assert.IsEqual(R, [' ', 'AA'])
71+
})
72+
Test('Should Const Multi-Whitespace 6', () => {
73+
const R: [' ', 'AA '] = Token.Const(' AA ', ' ')
74+
Assert.IsEqual(R, [' ', 'AA '])
75+
})
76+
77+
// ------------------------------------------------------------------
78+
// Const: Newline
79+
// ------------------------------------------------------------------
80+
Test('Should Const Newline 1', () => {
81+
const R: [] = Token.Const('', '\n')
82+
Assert.IsEqual(R, [])
83+
})
84+
Test('Should Const Newline 2', () => {
85+
const R: [] = Token.Const(' ', '\n')
86+
Assert.IsEqual(R, [])
87+
})
88+
Test('Should Const Newline 3', () => {
89+
const R: ['\n', 'A'] = Token.Const('\nA', '\n')
90+
Assert.IsEqual(R, ['\n', 'A'])
91+
})
92+
Test('Should Const Newline 4', () => {
93+
const R: ['\n', 'A '] = Token.Const(' \nA ', '\n')
94+
Assert.IsEqual(R, ['\n', 'A '])
95+
})
96+
Test('Should Const Newline 5', () => {
97+
const R: ['\n', 'AA'] = Token.Const(' \nAA', '\n')
98+
Assert.IsEqual(R, ['\n', 'AA'])
99+
})
100+
Test('Should Const Newline 6', () => {
101+
const R: ['\n', 'AA '] = Token.Const(' \nAA ', '\n')
102+
Assert.IsEqual(R, ['\n', 'AA '])
103+
})
104+
105+
// ------------------------------------------------------------------
106+
// Const: Newline-Single-Whitespace
107+
// ------------------------------------------------------------------
108+
Test('Should Const Newline-Single-WS 1', () => {
109+
const R: [] = Token.Const('', '\n ')
110+
Assert.IsEqual(R, [])
111+
})
112+
Test('Should Const Newline-Single-WS 2', () => {
113+
const R: [] = Token.Const(' ', '\n ')
114+
Assert.IsEqual(R, [])
115+
})
116+
Test('Should Const Newline-Single-WS 3', () => {
117+
const R: [] = Token.Const('\nA', '\n ')
118+
Assert.IsEqual(R, [])
119+
})
120+
Test('Should Const Newline-Single-WS 4', () => {
121+
const R: [] = Token.Const(' \nA ', '\n ')
122+
Assert.IsEqual(R, [])
123+
})
124+
Test('Should Const Newline-Single-WS 5', () => {
125+
const R: [] = Token.Const(' \nAA', '\n ')
126+
Assert.IsEqual(R, [])
127+
})
128+
Test('Should Const Newline-Single-WS 6', () => {
129+
const R: [] = Token.Const(' \nAA ', '\n ')
130+
Assert.IsEqual(R, [])
131+
})
132+
Test('Should Const Newline-Single-WS 7', () => {
133+
const R: ['\n ', 'A'] = Token.Const('\n A', '\n ')
134+
Assert.IsEqual(R, ['\n ', 'A'])
135+
})
136+
Test('Should Const Newline-Single-WS 8', () => {
137+
const R: ['\n ', 'A '] = Token.Const(' \n A ', '\n ')
138+
Assert.IsEqual(R, ['\n ', 'A '])
139+
})
140+
Test('Should Const Newline-Single-WS 9', () => {
141+
const R: ['\n ', 'AA'] = Token.Const(' \n AA', '\n ')
142+
Assert.IsEqual(R, ['\n ', 'AA'])
143+
})
144+
Test('Should Const Newline-Single-WS 10', () => {
145+
const R: ['\n ', 'AA '] = Token.Const(' \n AA ', '\n ')
146+
Assert.IsEqual(R, ['\n ', 'AA '])
147+
})
148+
149+
// ------------------------------------------------------------------
150+
// Const: Newline-Multi-Whitespace
151+
// ------------------------------------------------------------------
152+
Test('Should Const Newline-Multi-WS 1', () => {
153+
const R: [] = Token.Const('', '\n ')
154+
Assert.IsEqual(R, [])
155+
})
156+
Test('Should Const Newline-Multi-WS 2', () => {
157+
const R: [] = Token.Const(' ', '\n ')
158+
Assert.IsEqual(R, [])
159+
})
160+
Test('Should Const Newline-Multi-WS 3', () => {
161+
const R: [] = Token.Const('\n A', '\n ')
162+
Assert.IsEqual(R, [])
163+
})
164+
Test('Should Const Newline-Multi-WS 4', () => {
165+
const R: [] = Token.Const(' \n A ', '\n ')
166+
Assert.IsEqual(R, [])
167+
})
168+
Test('Should Const Newline-Multi-WS 5', () => {
169+
const R: [] = Token.Const(' \n AA', '\n ')
170+
Assert.IsEqual(R, [])
171+
})
172+
Test('Should Const Newline-Multi-WS 6', () => {
173+
const R: [] = Token.Const(' \n AA ', '\n ')
174+
Assert.IsEqual(R, [])
175+
})
176+
Test('Should Const Newline-Multi-WS 7', () => {
177+
const R: ['\n ', 'A'] = Token.Const('\n A', '\n ')
178+
Assert.IsEqual(R, ['\n ', 'A'])
179+
})
180+
Test('Should Const Newline-Multi-WS 8', () => {
181+
const R: ['\n ', 'A '] = Token.Const(' \n A ', '\n ')
182+
Assert.IsEqual(R, ['\n ', 'A '])
183+
})
184+
Test('Should Const Newline-Multi-WS 9', () => {
185+
const R: ['\n ', 'AA'] = Token.Const(' \n AA', '\n ')
186+
Assert.IsEqual(R, ['\n ', 'AA'])
187+
})
188+
Test('Should Const Newline-Multi-WS 10', () => {
189+
const R: ['\n ', 'AA '] = Token.Const(' \n AA ', '\n ')
190+
Assert.IsEqual(R, ['\n ', 'AA '])
191+
})

0 commit comments

Comments
 (0)