deno.land / x / solid@v1.5.6 / test / signals.type-tests.ts
نووسراو ببینە
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001import { createEffect, createComputed, createRenderEffect, createMemo, Accessor, on, createSignal, Signal, Setter // } from "../types/index";} from "../src";
class Animal { #animal = null;}class Dog extends Animal { #dog = null;}
//////////////////////////////////////////////////////////////////////////// createEffect //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
createEffect(() => { return "hello";}, "init");
createEffect(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string = prev; return p + "hello";}, "init");
createEffect((prev: string) => { const p: string = prev; return p + "hello";}, "init");
createEffect(() => { return "hello";}, 123);
createEffect(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string = prev; return p + "hello";}, 123);
createEffect((prev: number | string) => { const p: number | string = prev; return p + "hello";}, 123);
createEffect(() => { return "hello";});
createEffect(_prev => { return "hello";});
createEffect(_prev => {});
createEffect((v: number | string): number => 123, "asdf");
createEffect((num: number | undefined): number | undefined => 123);
createEffect((num?: number): number | undefined => 123);
createEffect<number>((v: number | string): number => 123, 123);createEffect<number | string>((v: number | string): number => 123, 123);
// @ts-expect-error undefined initial value not assignable to input parametercreateEffect((v: number | boolean): number | boolean => false);
createEffect((v: Animal): Dog => new Dog(), new Dog());createEffect((v: Animal): Dog => new Dog(), new Animal());createEffect( // @ts-expect-error the Animal arg is not assignable to the Dog parameter (v: Dog): Dog => new Dog(), new Animal());// @ts-expect-error the missing second arg is undefined, and undefined is not assignable to the Animal parametercreateEffect((v: Animal): Dog => new Dog());
createEffect<number | boolean>( // @ts-expect-error because if number|boolean were returnable from the passed-in function, it wouldn't be assignable to the input of that function. // TODO can we improve this? Technically, the return type of the function is always assignable to number|boolean, which is really all we should care about. (v: number | string): number => 123, 123);
createEffect((v: number | string): number => 123, "asdf");
createEffect((v: number) => 123, 123);
createEffect( (v?: number) => { return 123; }, 123, {});createEffect(() => 123);createEffect(() => {});createEffect( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {});// @ts-expect-error undefined initial value is not assignable to the number parametercreateEffect((v: number) => 123);createEffect(() => { return 123;}, 123);createEffect(() => { return 123;}, undefined);createEffect((v: number) => 123, 123);createEffect((v?: number) => 123, undefined);createEffect<number | undefined>( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {}, 123);createEffect<number | undefined>( // @ts-expect-error the void return is not assignable to the explicitly specified number|undefined return v => {}, 123);createEffect( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {}, undefined);createEffect(v => {}); // useless, but ok// @ts-expect-error the void return is not assignable to the number|undefined parametercreateEffect((v: number) => {});createEffect( // @ts-expect-error void return not assignable to number parameter (v: number) => {}, 123);createEffect( // @ts-expect-error undefined second arg is not assignable to the number parameter (v: number) => {}, undefined);// @ts-expect-error undefined second arg is not assignable to the number parametercreateEffect((v: number) => 123, undefined);// @ts-expect-error void not assignable to number|undefinedcreateEffect((v?: number) => {}, 123);
//////////////////////////////////////////////////////////////////////////// createComputed //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
createComputed(() => { return "hello";}, "init");
createComputed(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string = prev; return p + "hello";}, "init");
createComputed((prev: string) => { const p: string = prev; return p + "hello";}, "init");
createComputed(() => { return "hello";}, 123);
createComputed(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string = prev; return p + "hello";}, 123);
createComputed((prev: number | string) => { const p: number | string = prev; return p + "hello";}, 123);
createComputed(() => { return "hello";});
createComputed(_prev => { return "hello";});
createComputed(_prev => {});
createComputed((v: number | string): number => 123, "asdf");
createComputed((num: number | undefined): number | undefined => 123);
createComputed((num?: number): number | undefined => 123);
createComputed<number>((v: number | string): number => 123, 123);createComputed<number | string>((v: number | string): number => 123, 123);
// @ts-expect-error undefined initial value not assignable to input parametercreateComputed((v: number | boolean): number | boolean => false);
createComputed((v: Animal): Dog => new Dog(), new Dog());createComputed((v: Animal): Dog => new Dog(), new Animal());createComputed( // @ts-expect-error the Animal arg is not assignable to the Dog parameter (v: Dog): Dog => new Dog(), new Animal());// @ts-expect-error the missing second arg is undefined, and undefined is not assignable to the Animal parametercreateComputed((v: Animal): Dog => new Dog());
createComputed<number | boolean>( // @ts-expect-error because if number|boolean were returnable from the passed-in function, it wouldn't be assignable to the input of that function. // TODO can we improve this? Technically, the return type of the function is always assignable to number|boolean, which is really all we should care about. (v: number | string): number => 123, 123);
createComputed((v: number | string): number => 123, "asdf");
createComputed((v: number) => 123, 123);
createComputed( (v?: number) => { return 123; }, 123, {});createComputed(() => 123);createComputed(() => {});createComputed( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {});// @ts-expect-error undefined initial value is not assignable to the number parametercreateComputed((v: number) => 123);createComputed(() => { return 123;}, 123);createComputed(() => { return 123;}, undefined);createComputed((v: number) => 123, 123);createComputed((v?: number) => 123, undefined);createComputed<number | undefined>( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {}, 123);createComputed<number | undefined>( // @ts-expect-error the void return is not assignable to the explicitly specified number|undefined return v => {}, 123);createComputed( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {}, undefined);createComputed(v => {}); // useless, but ok// @ts-expect-error the void return is not assignable to the number|undefined parametercreateComputed((v: number) => {});createComputed( // @ts-expect-error void return not assignable to number parameter (v: number) => {}, 123);createComputed( // @ts-expect-error undefined second arg is not assignable to the number parameter (v: number) => {}, undefined);// @ts-expect-error undefined second arg is not assignable to the number parametercreateComputed((v: number) => 123, undefined);// @ts-expect-error void not assignable to number|undefinedcreateComputed((v?: number) => {}, 123);
//////////////////////////////////////////////////////////////////////////// createRenderEffect //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
createRenderEffect(() => { return "hello";}, "init");
createRenderEffect(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string = prev; return p + "hello";}, "init");
createRenderEffect((prev: string) => { const p: string = prev; return p + "hello";}, "init");
createRenderEffect(() => { return "hello";}, 123);
createRenderEffect(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string = prev; return p + "hello";}, 123);
createRenderEffect((prev: number | string) => { const p: number | string = prev; return p + "hello";}, 123);
createRenderEffect(() => { return "hello";});
createRenderEffect(_prev => { return "hello";});
createRenderEffect(_prev => {});
createRenderEffect((v: number | string): number => 123, "asdf");
createRenderEffect((num: number | undefined): number | undefined => 123);
createRenderEffect((num?: number): number | undefined => 123);
createRenderEffect<number>((v: number | string): number => 123, 123);createRenderEffect<number | string>((v: number | string): number => 123, 123);
// @ts-expect-error undefined initial value not assignable to input parametercreateRenderEffect((v: number | boolean): number | boolean => false);
createRenderEffect((v: Animal): Dog => new Dog(), new Dog());createRenderEffect((v: Animal): Dog => new Dog(), new Animal());createRenderEffect( // @ts-expect-error the Animal arg is not assignable to the Dog parameter (v: Dog): Dog => new Dog(), new Animal());// @ts-expect-error the missing second arg is undefined, and undefined is not assignable to the Animal parametercreateRenderEffect((v: Animal): Dog => new Dog());
createRenderEffect<number | boolean>( // @ts-expect-error because if number|boolean were returnable from the passed-in function, it wouldn't be assignable to the input of that function. // TODO can we improve this? Technically, the return type of the function is always assignable to number|boolean, which is really all we should care about. (v: number | string): number => 123, 123);
createRenderEffect((v: number | string): number => 123, "asdf");
createRenderEffect((v: number) => 123, 123);
createRenderEffect( (v?: number) => { return 123; }, 123, {});createRenderEffect(() => 123);createRenderEffect(() => {});createRenderEffect( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {});// @ts-expect-error undefined initial value is not assignable to the number parametercreateRenderEffect((v: number) => 123);createRenderEffect(() => { return 123;}, 123);createRenderEffect(() => { return 123;}, undefined);createRenderEffect((v: number) => 123, 123);createRenderEffect((v?: number) => 123, undefined);createRenderEffect<number | undefined>( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {}, 123);createRenderEffect<number | undefined>( // @ts-expect-error the void return is not assignable to the explicitly specified number|undefined return v => {}, 123);createRenderEffect( // @ts-expect-error the void return is not assignable to the number|undefined parameter (v?: number) => {}, undefined);createRenderEffect(v => {}); // useless, but ok// @ts-expect-error the void return is not assignable to the number|undefined parametercreateRenderEffect((v: number) => {});createRenderEffect( // @ts-expect-error void return not assignable to number parameter (v: number) => {}, 123);createRenderEffect( // @ts-expect-error undefined second arg is not assignable to the number parameter (v: number) => {}, undefined);// @ts-expect-error undefined second arg is not assignable to the number parametercreateRenderEffect((v: number) => 123, undefined);// @ts-expect-error void not assignable to number|undefinedcreateRenderEffect((v?: number) => {}, 123);
//////////////////////////////////////////////////////////////////////////// createMemo //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
createMemo((v: number | string): number => 123, "asdf");
createMemo((num: number | undefined): number | undefined => 123);
// Return type should be `Accessor<number | undefined>`// Not sure how to write a test for this, becacuse `Accessor<number>` is assignable to `Accessor<number | undefined>`.let c1 = createMemo((num?: number): number | undefined => undefined);let n = c1();// @ts-expect-error n might be undefinedconst n2 = n + 3; // n is undefined
createMemo<number>((v: number | string): number => 123, 123);createMemo<number | string>((v: number | string): number => 123, 123);
// @ts-expect-error undefined initial value not assignable to input parametercreateMemo((v: number | boolean): number | boolean => false);
createMemo((v: Animal): Dog => new Dog(), new Dog());createMemo((v: Animal): Dog => new Dog(), new Animal());createMemo( // @ts-expect-error the Animal arg is not assignable to the Dog parameter (v: Dog): Dog => new Dog(), new Animal());// @ts-expect-error the missing second arg is undefined, and undefined is not assignable to the Animal parametercreateMemo((v: Animal): Dog => new Dog());
createMemo<number | boolean>( // @ts-expect-error because if number|boolean were returnable from the passed-in function, it wouldn't be assignable to the input of that function. // TODO can we improve this? Technically, the return type of the function is always assignable to number|boolean, which is really all we should care about. (v: number | string): number => 123, 123);
createMemo((v: number | string): number => 123, "asdf");
createMemo((v: number) => 123, 123);
const mv0 = createMemo(() => { return "hello";}, "init");const mv0t: string = mv0();
const mv1 = createMemo(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string = prev; return p + "hello";}, "init");const mv1t: string = mv1();
const mv11 = createMemo((prev: string) => { const p: string = prev; return p + "hello";}, "init");const mv11t: string = mv11();
const mv2 = createMemo(() => { return "hello";}, 123);const mv2t: string = mv2();
const mv3 = createMemo(prev => { // @ts-expect-error FIXME prev is inferred as unknown, so not assignable to string|number. Can we make it inferred? const p: string | number = prev; return p + "hello";}, 123);const mv3t: string = mv3();
const mv31 = createMemo((prev: string | number) => { const p: string | number = prev; return p + "hello";}, 123);const mv31t: string = mv31();
const mv4 = createMemo(() => { return "hello";});const mv4t: string = mv4();
const mv5 = createMemo(_prev => { return "hello";});const mv5t: string = mv5();
const mv6 = createMemo(() => {});const mv6t: void = mv6();
const mv7 = createMemo(_prev => {});const mv7t: void = mv7();
const v1 = createMemo( (v?: number) => { return 123; }, 123, {});const v2 = createMemo(() => 123);// @ts-expect-error number return value can not be assigned to the input string argconst v3 = createMemo((v: string) => 123);const v4 = createMemo(v => 123);const v5 = createMemo(() => {});// @ts-expect-error because void return of the effect function cannot be assigned to number | undefined of the effect function's parameterconst v6 = createMemo((v?: number) => {});const v7 = createMemo(() => 123, 123);const v8 = createMemo(() => 123, undefined);// @ts-expect-error undefined initial value is not assignable to the number parameterconst v9 = createMemo((v: number) => 123);const v10 = createMemo((v: number) => 123, 123);const v11 = createMemo((v?: number) => 123, 123);const v12 = createMemo((v?: number) => 123, undefined);const v13 = createMemo((v?: number) => 123, 123);const v14 = createMemo<number | undefined>( // @ts-expect-error because void return of the effect function cannot be assigned to number | undefined of the effect function's parameter (v?: number) => {}, 123);const v15 = createMemo<number | undefined>( // @ts-expect-error effect function does not match the specified memo type v => {}, 123);const v16 = createMemo( // @ts-expect-error because void return of the effect function cannot be assigned to number | undefined of the effect function's parameter (v?: number) => {}, undefined);const v17 = createMemo(v => {});// @ts-expect-error because void return of the effect function cannot be assigned to number | undefined of the effect function's parameterconst v18 = createMemo((v: number) => {});const v19 = createMemo( // @ts-expect-error void is not assignable to anything (v: number) => {}, 123);const v20 = createMemo( // @ts-expect-error clearly undefined can't be assigned into the input parameter of the effect function (v: number) => {}, undefined);const v21 = // @ts-expect-error and this one makes complete sense, undefined cannot go into the effect function's number parameter. createMemo((v: number) => 123, undefined);const v22 = createMemo( // @ts-expect-error because void return of the effect function cannot be assigned to number | undefined of the effect function's parameter (v?: number) => {}, 123);
const m: Accessor<number> = createMemo( (v?: number) => { return 123; }, 123, {});const m2: Accessor<number | undefined> = createMemo(() => 123);// @ts-expect-error void can't be assigned to anything!const m3: //Accessor<undefined> = createMemo(() => {});const m4: Accessor<void> = createMemo(() => {});// @ts-expect-error void can't be assigned to anything!const m5: Accessor<number | undefined> = createMemo( // @ts-expect-error void can't be assigned to anything! (v?: number) => {});const mm5 = createMemo( // @ts-expect-error void can't be assigned to anything! (v?: number) => {});const m6: Accessor<number> = createMemo(() => 123, 123);const m7: Accessor<number | undefined> = createMemo(() => 123, undefined);const m8: Accessor<number> = createMemo((v: number) => 123, 123);const m9: Accessor<number | undefined> = createMemo((v?: number) => 123, undefined);const m10: Accessor<number | undefined> = createMemo<number | undefined>( // @ts-expect-error void can't be assigned to anything! (v?: number) => {}, 123);const m11: Accessor<number | undefined> = createMemo<number | undefined>( // @ts-expect-error void can't be assigned to anything! v => {}, 123);const m12: Accessor<number | undefined> = createMemo( // @ts-expect-error void can't be assigned to anything! (v?: number) => {}, undefined);const m13 = createMemo((v?: number): number | undefined => 123, undefined);const testm13: Accessor<number | undefined> = m13;const m14: Accessor<number> = createMemo((v?: number): number => 123, undefined);const m15: Accessor<number> = // @ts-expect-error undefined initial value is not assignable to the number parameter createMemo((v: number): number => 123);const m16: Accessor<number> = // @ts-expect-error undefined initial value can't be assign to the number parameter createMemo((v: number): number => 123, undefined);const m17: Accessor<number> = // @ts-expect-error no overload matches because the second string arg cannot be assigned to the number|boolean parameter. createMemo((v: number | boolean): number => 123, "asdf");const m18: Accessor<number> = // @ts-expect-error undefined initial value is not assignable to the number parameter createMemo((v: number | boolean): number => 123);const m19: Accessor<number> = // @ts-expect-error undefined initial value is not assignable to the number parameter createMemo((v: number | string): number => 123);const m20: Accessor<number> = // @ts-expect-error because the number return cannot be assigned to the boolean|string parameter createMemo((v: boolean | string): number => 123);const m21: Accessor<number> = // @ts-expect-error because the second boolean arg cannot be assigned to the number|string parameter. createMemo((v: number | string): number => 123, true);const m22: Accessor<number> = createMemo((v: number | string): number => 123, "asdf");const m23: Accessor<number> = createMemo((v?: number | string): number => 123, undefined);const m24: Accessor<number> = // @ts-expect-error true not assignable to number|string createMemo((v: number | string): number => 123, true);
const asdf = createMemo<number | undefined>(() => num());// @ts-expect-error Accessor<number | undefined> is not assignable to Accessor<number>const asdf2: //Accessor<number> = asdf;
//////////////////////////////////////////////////////////////////////////// on //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const one = (): number => 123;const two = () => Boolean(Math.random());createEffect( on( (): [number, boolean] => [1, true], (input, prevInput, prev) => { const [one, two]: [number, boolean] = input; if (prevInput) { const [prevOne, prevTwo]: [number, boolean] = prevInput; } // @ts-expect-error FIXME computed type is unknown, should be `number`. const _prev: number = prev; return one + +two; } ));const onMemo1 = createMemo( on([one, two], (input, prevInput, prev) => { const [one, two]: [number, boolean] = input; if (prevInput) { const [prevOne, prevTwo]: [number, boolean] = prevInput; } // @ts-expect-error FIXME computed type is unknown, should be `number`. const _prev: number = prev; return one + +two; }));const onMemo2: Accessor<number> = onMemo1;createEffect( on( [one, two], (input, prevInput, prev) => { const [one, two]: [number, boolean] = input; if (prevInput) { const [prevOne, prevTwo]: [number, boolean] = prevInput; } // @ts-expect-error FIXME computed type is unknown, should be `number`. const _prev: number = prev; return one + +two; }, { defer: true } ));const onMemo3 = createMemo( on( [one, two], (input, prevInput, prev) => { const [one, two]: [number, boolean] = input; if (prevInput) { const [prevOne, prevTwo]: [number, boolean] = prevInput; } // @ts-expect-error FIXME computed type is unknown, should be `number`. const _prev: number = prev; return one + +two; }, { defer: true } ));// @ts-expect-error when deferred the type includes undefinedconst onMemo4: Accessor<number> = onMemo3;
//////////////////////////////////////////////////////////////////////////// variations of signal types //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const [num, setN] = createSignal(1);let n1: number = num();setN(123);setN(n => (n1 = n + 1));// @ts-expect-error Expected 1 arguments, but got 0. ts(2554)setN();
const [num3, setN3] = createSignal<number>();// @ts-expect-error Type 'undefined' is not assignable to type 'number'. ts(2322)let n3: number = num3();setN3(123);setN3(undefined); // ok, accepts undefined// @ts-expect-error Object is possibly 'undefined'. ts(2532) (the `n` value)setN3(n => (n3 = n + 1));setN3(); // ok, accepts undefined
// @ts-expect-error Argument of type 'boolean' is not assignable to parameter of type 'number'. ts(2345)const [num4, setN4] = createSignal<number>(true);
const [bool, setBool] = createSignal(true);let b1: boolean = bool();setBool(false);setBool(b => (b1 = !b));// @ts-expect-error Expected 1 arguments, but got 0. ts(2554)setBool();
const [bool2, setBool2] = createSignal<boolean>();// @ts-expect-error Type 'undefined' is not assignable to type 'number'. ts(2322)let n4: boolean = bool2();setBool2(false);setBool2(undefined); // ok, accepts undefinedsetBool2(n => (n4 = !n)); // ok because undefined is being converted to boolean// @ts-expect-error Type 'boolean | undefined' is not assignable to type 'boolean'. ts(2322)setBool2(n => (n4 = n));setBool2(); // ok, accepts undefined
const [func, setFunc] = createSignal(() => 1);// @ts-expect-error 1 is not assignable to function (no overload matches)setFunc(() => 1);setFunc(() => (): 1 => 1); // ok, set the value to a functionconst fn: () => 1 = func(); // ok, returns function valueconst n5: 1 = func()();
const [func2, setFunc2] = createSignal<() => number>(() => 1);// @ts-expect-error number is not assignable to function (no overload matches)setFunc2(() => 1);setFunc2(() => () => 1); // ok, set the value to a functionconst fn2: () => number = func2(); // ok, returns function valueconst n6: number = func2()();
const [stringOrFunc1, setStringOrFunc1] = createSignal<(() => number) | string>("");// @ts-expect-error number should not be assignable to stringsetStringOrFunc1(() => 1);const sf1: () => 1 = setStringOrFunc1(() => () => 1);const sf2: "oh yeah" = setStringOrFunc1("oh yeah");const sf3: "oh yeah" = setStringOrFunc1(() => "oh yeah");// @ts-expect-error cannot set signal to undefinedsetStringOrFunc1();// @ts-expect-error cannot set signal to undefinedsetStringOrFunc1(undefined);// @ts-expect-error return value might be stringconst sf6: () => number = stringOrFunc1();const sf7: (() => number) | string | undefined = stringOrFunc1();const sf8: (() => number) | string = stringOrFunc1();
const [stringOrFunc2, setStringOrFunc2] = createSignal<(() => number) | string>();// @ts-expect-error number should not be assignable to stringsetStringOrFunc2(() => 1);const sf9: () => 1 = setStringOrFunc2(() => () => 1);const sf10: "oh yeah" = setStringOrFunc2("oh yeah");const sf11: "oh yeah" = setStringOrFunc2(() => "oh yeah");const sf12: undefined = setStringOrFunc2();const sf13: undefined = setStringOrFunc2(undefined);const sf14: (() => number) | string | undefined = stringOrFunc2();// @ts-expect-error return value might be undefinedconst sf15: (() => number) | string = stringOrFunc2();
const [stringOrNumber, setStringOrNumber] = createSignal<string | number>(1);setStringOrNumber(1 as number | string);setStringOrNumber(1);setStringOrNumber("" as number | string);setStringOrNumber("");
function createGenericSignal<T>(): Signal<T | undefined> { const [generic, setGeneric] = createSignal<T>(); const customSet: Setter<T | undefined> = (v?) => setGeneric(v); return [generic, (v?) => setGeneric(v)];}
function createInitializedSignal<T>(init: T): Signal<T> { const [generic, setGeneric] = createSignal<T>(init); const customSet: Setter<T> = (v?) => setGeneric(v); return [generic, (v?) => setGeneric(v)];}
//////////////////////////////////////////////////////////////////////////// test explicit generic args //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
const a1: Accessor<number> = createMemo<number>(() => num());createEffect<number>(() => num());createComputed<number>(() => num());createRenderEffect<number>(() => num());
const a11: Accessor<number> = createMemo<number>((v?: number) => num());createEffect<number>((v?: number) => num());createComputed<number>((v?: number) => num());createRenderEffect<number>((v?: number) => num());
const a12: Accessor<number> = createMemo<number>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createEffect<number>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createComputed<number>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createRenderEffect<number>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());
//
const a2: Accessor<number | undefined> = createMemo<number | undefined>(() => num());createEffect<number | undefined>(() => num());createComputed<number | undefined>(() => num());createRenderEffect<number | undefined>(() => num());
const a21: Accessor<number | undefined> = createMemo<number | undefined>((v?: number) => num());createEffect<number | undefined>((v?: number) => num());createComputed<number | undefined>((v?: number) => num());createRenderEffect<number | undefined>((v?: number) => num());
const a22: Accessor<number | undefined> = createMemo<number | undefined>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createEffect<number | undefined>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createComputed<number | undefined>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createRenderEffect<number | undefined>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());
//
const a3: Accessor<number | boolean> = createMemo<number | boolean>(() => bool());createEffect<number | boolean>(() => bool());createComputed<number | boolean>(() => bool());createRenderEffect<number | boolean>(() => bool());
// FIXME// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.const a31: Accessor<number | boolean> = createMemo<number | boolean>((v?: number) => num());// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.createEffect<number | boolean>((v?: number) => num());// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.createComputed<number | boolean>((v?: number) => num());// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.createRenderEffect<number | boolean>((v?: number) => num());
const a32: Accessor<number | boolean> = createMemo<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createEffect<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createComputed<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createRenderEffect<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());
//
const a4: Accessor<number | boolean> = createMemo<number | boolean>(() => bool());createEffect<number | boolean>(() => bool());createComputed<number | boolean>(() => bool());createRenderEffect<number | boolean>(() => bool());
// FIXME// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.const a41: Accessor<number | boolean> = createMemo<number | boolean>((v?: number) => num());// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.createEffect<number | boolean>((v?: number) => num());// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.createComputed<number | boolean>((v?: number) => num());// @ts-expect-error this rare edge cases is not handled yet. The number return from the effect function should be assignable to number|boolean, while the initial value should be inferred as number|undefined.createRenderEffect<number | boolean>((v?: number) => num());
const a42: Accessor<number | boolean> = createMemo<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createEffect<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createComputed<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());createRenderEffect<number | boolean>( // @ts-expect-error the function accepts only `number` but the initial value will be `undefined`. (v: number) => num());
//
const a5: Accessor<number | boolean> = createMemo<number | boolean>(() => bool(), false);createEffect<number | boolean>(() => bool(), false);createComputed<number | boolean>(() => bool(), false);createRenderEffect<number | boolean>(() => bool(), false);
// 👽const a51: Accessor<number | boolean> = createMemo<number | boolean>( () => bool(), // @ts-expect-error FIXME edge case: string is not assignable to number|boolean, but really it should say that the effect function expects 0 args but 1 arg was provided. "foo");createEffect<number | boolean>( () => bool(), // @ts-expect-error FIXME edge case: string is not assignable to number|boolean, but really it should say that the effect function expects 0 args but 1 arg was provided. "foo");createComputed<number | boolean>( () => bool(), // @ts-expect-error FIXME edge case: string is not assignable to number|boolean, but really it should say that the effect function expects 0 args but 1 arg was provided. "foo");createRenderEffect<number | boolean>( () => bool(), // @ts-expect-error FIXME edge case: string is not assignable to number|boolean, but really it should say that the effect function expects 0 args but 1 arg was provided. "foo");
//
const a6: Accessor<number | boolean> = createMemo<number | boolean>( () => // @ts-expect-error string return is not assignable to number|boolean "foo");createEffect<number | boolean>( () => // @ts-expect-error string return is not assignable to number|boolean "foo");createComputed<number | boolean>( () => // @ts-expect-error string return is not assignable to number|boolean "foo");createRenderEffect<number | boolean>( () => // @ts-expect-error string return is not assignable to number|boolean "foo");
// FIXME cases failing due to partial generic inference not being implemented// @ts-expect-error second generic is not inferred and remains as numberconst a7: Accessor<number> = createMemo<number>((v: number | string) => 123, "asd");// @ts-expect-error second generic is not inferred and remains as numbercreateEffect<number>((v: number | string) => 123, "asd");// @ts-expect-error second generic is not inferred and remains as numbercreateComputed<number>((v: number | string) => 123, "asd");// @ts-expect-error second generic is not inferred and remains as numbercreateRenderEffect<number>((v: number | string) => 123, "asd");
solid
Version Info
a year ago
