Replace: Add support for generating longer strings (#1060)

Author: som-sm

source/replace.d.ts

@@ -60,8 +60,16 @@ export type Replace<
 	Search extends string,
 	Replacement extends string,
 	Options extends ReplaceOptions = {},
+> = _Replace<Input, Search, Replacement, Options>;
+
+type _Replace<
+	Input extends string,
+	Search extends string,
+	Replacement extends string,
+	Options extends ReplaceOptions,
+	Accumulator extends string = '',
 > = Input extends `${infer Head}${Search}${infer Tail}`
 	? Options['all'] extends true
-		? `${Head}${Replacement}${Replace<Tail, Search, Replacement, Options>}`
+		? _Replace<Tail, Search, Replacement, Options, `${Accumulator}${Head}${Replacement}`>
 		: `${Head}${Replacement}${Tail}`
-	: Input;
+	: `${Accumulator}${Input}`;

test-d/replace.ts

@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {Replace} from '../index';
+import type {Replace, StringRepeat} from '../index';
 
 declare function replace<
 	Input extends string,
@@ -27,3 +27,13 @@ expectType<'10-42-00'>(replaceAll('10:42:00', ':', '-'));
 expectType<'userName'>(replaceAll('__userName__', '__', ''));
 expectType<'MyCoolTitle'>(replaceAll('My Cool Title', ' ', ''));
 expectType<'fobarfobar'>(replaceAll('foobarfoobar', 'ob', 'b'));
+
+// Recursion depth at which a non-tail recursive implementation starts to fail.
+type FiftyZeroes = StringRepeat<'0', 50>;
+type FiftyOnes = StringRepeat<'1', 50>;
+expectType<FiftyOnes>({} as Replace<FiftyZeroes, '0', '1', {all: true}>);
+
+// Maximum allowed recursion depth for a tail recursive implementation.
+type NineHundredNinetyNineZeroes = StringRepeat<'0', 999>;
+type NineHundredNinetyNineOnes = StringRepeat<'1', 999>;
+expectType<NineHundredNinetyNineOnes>({} as Replace<NineHundredNinetyNineZeroes, '0', '1', {all: true}>);

test-d/split.ts

@@ -1,5 +1,5 @@
 import {expectType} from 'tsd';
-import type {Split} from '../index';
+import type {Split, StringRepeat} from '../index';
 import type {BuildTuple} from '../source/internal';
 
 declare function split<
@@ -31,9 +31,9 @@ expectType<[]>(split('', ''));
 expectType<['']>(split('', ' '));
 
 // Recursion depth at which a non-tail recursive implementation starts to fail.
-const fiftyZeroes = '00000000000000000000000000000000000000000000000000';
-expectType<BuildTuple<50, '0'>>(split(fiftyZeroes, ''));
+type FiftyZeroes = StringRepeat<'0', 50>;
+expectType<BuildTuple<50, '0'>>({} as Split<FiftyZeroes, ''>);
 
 // Maximum allowed recursion depth for a tail recursive implementation.
-const nineHundredNinetyNineZeroes = '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
-expectType<BuildTuple<999, '0'>>(split(nineHundredNinetyNineZeroes, ''));
+type NineHundredNinetyNineZeroes = StringRepeat<'0', 999>;
+expectType<BuildTuple<999, '0'>>({} as Split<NineHundredNinetyNineZeroes, ''>);