Skip to content

Commit 26cd700

Browse files
hlysinehlysine
committed
Simplify TS types
Previously, the types are very specific, but the TS compiler doesn't handle recursive types well, causing a lot of usage to reach max recursive depth. Instead of leaving the library completely unusable, simplifying the types would at least fix the annoying error.
1 parent bff5292 commit 26cd700

File tree

3 files changed

+283
-165
lines changed

3 files changed

+283
-165
lines changed

‎src/expression.ts

+30-64
Original file line numberDiff line numberDiff line change
@@ -1,20 +1,14 @@
11
import {
22
AlternationFunction,
3-
CanBeNegated,
4-
CanBeQuantified,
53
CharClassFunction,
6-
ExtraQuantifiedToken,
74
FlagUnion,
85
FlagsString,
96
GroupFunction,
107
LiteralFunction,
11-
QuantifiedToken,
12-
QuantifierFunction,
138
RegExpLiteral,
149
RegExpModifier,
1510
RegExpToken,
16-
negatableSymbol,
17-
quantifiableSymbol,
11+
TokenFunction,
1812
} from './types';
1913
import {
2014
assign,
@@ -40,8 +34,6 @@ class RegExpBuilder implements RegExpToken {
4034
public readonly modifiers: RegExpModifier[];
4135
public readonly backreferences: (string | number)[];
4236
public readonly namedGroups: (string | number)[];
43-
public readonly [negatableSymbol]: undefined;
44-
public readonly [quantifiableSymbol]: undefined;
4537

4638
public constructor(
4739
regExp?: string,
@@ -226,7 +218,7 @@ class RegExpBuilder implements RegExpToken {
226218
}
227219

228220
public get exactly(): RegExpToken['exactly'] {
229-
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken & CanBeQuantified {
221+
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken {
230222
if (!isLiteralArgument(args)) throw new Error('Invalid arguments for exactly');
231223
const literal = getLiteralString(args);
232224
return this.addNode(literal);
@@ -235,7 +227,7 @@ class RegExpBuilder implements RegExpToken {
235227
}
236228

237229
public get octal(): RegExpToken['octal'] {
238-
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken & CanBeQuantified & CanBeNegated {
230+
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken {
239231
const literal = getLiteralString(args, false);
240232
if (!octalNumber.test(literal)) throw new Error('Invalid octal character');
241233
const num = Number.parseInt(literal, 8);
@@ -253,7 +245,7 @@ class RegExpBuilder implements RegExpToken {
253245
}
254246

255247
public get hex(): RegExpToken['hex'] {
256-
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken & CanBeQuantified & CanBeNegated {
248+
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken {
257249
const literal = getLiteralString(args, false);
258250
if (!hexNumber.test(literal)) throw new Error('Invalid hex character');
259251
const num = Number.parseInt(literal, 16);
@@ -265,7 +257,7 @@ class RegExpBuilder implements RegExpToken {
265257
}
266258

267259
public get unicode(): RegExpToken['unicode'] {
268-
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken & CanBeQuantified & CanBeNegated {
260+
function func(this: RegExpBuilder, ...args: RegExpLiteral): RegExpToken {
269261
const literal = getLiteralString(args, false);
270262
if (!hexNumber.test(literal)) throw new Error('Invalid unicode character');
271263
const num = Number.parseInt(literal, 16);
@@ -279,7 +271,7 @@ class RegExpBuilder implements RegExpToken {
279271
function func(
280272
this: RegExpBuilder,
281273
...args: RegExpLiteral | (string | RegExpToken)[]
282-
): RegExpToken & CanBeQuantified & CanBeNegated & CharClassFunction<CanBeNegated> {
274+
): RegExpToken & CharClassFunction {
283275
if (!(this.modifiers[0] instanceof CharacterClassModifier))
284276
throw new Error(`Unexpected modifier, expected CharacterClassModifier, but got ${this.modifiers[0]}`);
285277
if (isLiteralArgument(args)) {
@@ -314,7 +306,7 @@ class RegExpBuilder implements RegExpToken {
314306
}
315307

316308
public get not(): RegExpToken['not'] {
317-
function func(this: RegExpBuilder, token: RegExpToken & CanBeNegated): RegExpToken & CanBeQuantified {
309+
function func(this: RegExpBuilder, token: RegExpToken): RegExpToken {
318310
if (RegExpBuilder.isRegExpBuilder(token)) {
319311
return this.addNode(token);
320312
} else {
@@ -329,12 +321,8 @@ class RegExpBuilder implements RegExpToken {
329321
*/
330322

331323
public get repeat(): RegExpToken['repeat'] {
332-
function configure(
333-
this: RegExpBuilder,
334-
min: number,
335-
max?: number
336-
): LiteralFunction<CanBeQuantified> & QuantifierFunction & QuantifiedToken {
337-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken & CanBeQuantified {
324+
function configure(this: RegExpBuilder, min: number, max?: number): LiteralFunction & TokenFunction & RegExpToken {
325+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken {
338326
if (isLiteralArgument(args)) {
339327
const literal = getLiteralString(args);
340328
return this.addNode(literal);
@@ -350,22 +338,15 @@ class RegExpBuilder implements RegExpToken {
350338
}
351339

352340
public get repeatLazily(): RegExpToken['repeatLazily'] {
353-
function configure(
354-
this: RegExpBuilder,
355-
min: number,
356-
max?: number
357-
): LiteralFunction<CanBeQuantified> & QuantifierFunction & QuantifiedToken<'lazily'> {
341+
function configure(this: RegExpBuilder, min: number, max?: number): LiteralFunction & TokenFunction & RegExpToken {
358342
return this.repeat(min, max).lazily;
359343
}
360344
return bind(configure, this);
361345
}
362346

363347
public get atLeast(): RegExpToken['atLeast'] {
364-
function configure(
365-
this: RegExpBuilder,
366-
limit: number
367-
): LiteralFunction<CanBeQuantified> & QuantifierFunction & QuantifiedToken {
368-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken & CanBeQuantified {
348+
function configure(this: RegExpBuilder, limit: number): LiteralFunction & TokenFunction & RegExpToken {
349+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken {
369350
if (isLiteralArgument(args)) {
370351
const literal = getLiteralString(args);
371352
return this.addNode(literal);
@@ -381,21 +362,15 @@ class RegExpBuilder implements RegExpToken {
381362
}
382363

383364
public get atLeastLazily(): RegExpToken['atLeastLazily'] {
384-
function configure(
385-
this: RegExpBuilder,
386-
limit: number
387-
): LiteralFunction<CanBeQuantified> & QuantifierFunction & QuantifiedToken<'lazily'> {
365+
function configure(this: RegExpBuilder, limit: number): LiteralFunction & TokenFunction & RegExpToken {
388366
return this.atLeast(limit).lazily;
389367
}
390368
return bind(configure, this);
391369
}
392370

393371
public get atMost(): RegExpToken['atMost'] {
394-
function configure(
395-
this: RegExpBuilder,
396-
limit: number
397-
): LiteralFunction<CanBeQuantified> & QuantifierFunction & QuantifiedToken {
398-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken & CanBeQuantified {
372+
function configure(this: RegExpBuilder, limit: number): LiteralFunction & TokenFunction & RegExpToken {
373+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken {
399374
if (isLiteralArgument(args)) {
400375
const literal = getLiteralString(args);
401376
return this.addNode(literal);
@@ -411,17 +386,14 @@ class RegExpBuilder implements RegExpToken {
411386
}
412387

413388
public get atMostLazily(): RegExpToken['atMostLazily'] {
414-
function configure(
415-
this: RegExpBuilder,
416-
limit: number
417-
): LiteralFunction<CanBeQuantified> & QuantifierFunction & QuantifiedToken<'lazily'> {
389+
function configure(this: RegExpBuilder, limit: number): LiteralFunction & TokenFunction & RegExpToken {
418390
return this.atMost(limit).lazily;
419391
}
420392
return bind(configure, this);
421393
}
422394

423395
public get maybe(): RegExpToken['maybe'] {
424-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken & CanBeQuantified {
396+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken {
425397
if (isLiteralArgument(args)) {
426398
const literal = getLiteralString(args);
427399
return this.addNode(literal);
@@ -439,7 +411,7 @@ class RegExpBuilder implements RegExpToken {
439411
}
440412

441413
public get zeroOrMore(): RegExpToken['zeroOrMore'] {
442-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken & CanBeQuantified {
414+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken {
443415
if (isLiteralArgument(args)) {
444416
const literal = getLiteralString(args);
445417
return this.addNode(literal);
@@ -457,7 +429,7 @@ class RegExpBuilder implements RegExpToken {
457429
}
458430

459431
public get oneOrMore(): RegExpToken['oneOrMore'] {
460-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken & CanBeQuantified {
432+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken {
461433
if (isLiteralArgument(args)) {
462434
const literal = getLiteralString(args);
463435
return this.addNode(literal);
@@ -474,8 +446,8 @@ class RegExpBuilder implements RegExpToken {
474446
return this.oneOrMore.lazily;
475447
}
476448

477-
public get lazily(): ExtraQuantifiedToken['lazily'] {
478-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken & CanBeQuantified {
449+
public get lazily(): RegExpToken['lazily'] {
450+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken]): RegExpToken {
479451
if (isLiteralArgument(args)) {
480452
const literal = getLiteralString(args);
481453
return this.addNode(literal);
@@ -499,7 +471,7 @@ class RegExpBuilder implements RegExpToken {
499471
*/
500472

501473
public get capture(): RegExpToken['capture'] {
502-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken & CanBeQuantified {
474+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken {
503475
if (args.length === 0) {
504476
return this.addNode('');
505477
} else if (isLiteralArgument(args)) {
@@ -521,14 +493,14 @@ class RegExpBuilder implements RegExpToken {
521493
function configure(
522494
this: RegExpBuilder,
523495
...configArgs: RegExpLiteral
524-
): LiteralFunction<CanBeQuantified> & GroupFunction & RegExpToken {
496+
): LiteralFunction & GroupFunction & RegExpToken {
525497
if (!isLiteralArgument(configArgs)) {
526498
throw new Error('Invalid arguments for captureAs');
527499
}
528500
const name = getLiteralString(configArgs);
529501
if (!captureName.test(name))
530502
throw new Error('Invalid capture name. It must be alpha numeric and must not begin with a digit');
531-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken & CanBeQuantified {
503+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken {
532504
if (args.length === 0) {
533505
return this.addNode('');
534506
} else if (isLiteralArgument(args)) {
@@ -549,7 +521,7 @@ class RegExpBuilder implements RegExpToken {
549521
}
550522

551523
public get ref(): RegExpToken['ref'] {
552-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [number]): RegExpToken & CanBeQuantified {
524+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [number]): RegExpToken {
553525
if (args.length === 1 && typeof args[0] === 'number') {
554526
const index = args[0];
555527
if (index <= 0) throw new Error('Invalid group index in ref');
@@ -567,7 +539,7 @@ class RegExpBuilder implements RegExpToken {
567539
}
568540

569541
public get group(): RegExpToken['group'] {
570-
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken & CanBeQuantified {
542+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken {
571543
if (args.length === 0) {
572544
return this.addNode('');
573545
} else if (isLiteralArgument(args)) {
@@ -583,10 +555,7 @@ class RegExpBuilder implements RegExpToken {
583555
}
584556

585557
public get ahead(): RegExpToken['ahead'] {
586-
function func(
587-
this: RegExpBuilder,
588-
...args: RegExpLiteral | [RegExpToken?]
589-
): RegExpToken & CanBeQuantified & CanBeNegated {
558+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken {
590559
if (args.length === 0) {
591560
return this.addNode('');
592561
} else if (isLiteralArgument(args)) {
@@ -602,10 +571,7 @@ class RegExpBuilder implements RegExpToken {
602571
}
603572

604573
public get behind(): RegExpToken['behind'] {
605-
function func(
606-
this: RegExpBuilder,
607-
...args: RegExpLiteral | [RegExpToken?]
608-
): RegExpToken & CanBeQuantified & CanBeNegated {
574+
function func(this: RegExpBuilder, ...args: RegExpLiteral | [RegExpToken?]): RegExpToken {
609575
if (args.length === 0) {
610576
return this.addNode('');
611577
} else if (isLiteralArgument(args)) {
@@ -632,7 +598,7 @@ class RegExpBuilder implements RegExpToken {
632598
function func(
633599
this: RegExpBuilder,
634600
...args: RegExpLiteral | (string | RegExpToken)[]
635-
): RegExpToken & CanBeQuantified & AlternationFunction {
601+
): RegExpToken & AlternationFunction {
636602
if (!(this.modifiers[0] instanceof AlternationModifier))
637603
throw new Error(`Unexpected modifier, expected OneOfModifier, but got ${this.modifiers[0]}`);
638604
if (isLiteralArgument(args)) {
@@ -676,7 +642,7 @@ class RegExpBuilder implements RegExpToken {
676642
*/
677643

678644
public get match(): RegExpToken['match'] {
679-
function func(this: RegExpBuilder, token: RegExpToken): RegExpToken & CanBeQuantified {
645+
function func(this: RegExpBuilder, token: RegExpToken): RegExpToken {
680646
if (!RegExpBuilder.isRegExpBuilder(token)) throw new Error('Invalid arguments for match');
681647
return this.addNode(token);
682648
}

0 commit comments

Comments
 (0)