.gitignore added

[dotfiles/.git] / .config / coc / extensions / node_modules / coc-prettier / node_modules / type-fest / source / set-return-type.d.ts

diff --git a/.config/coc/extensions/node_modules/coc-prettier/node_modules/type-fest/source/set-return-type.d.ts b/.config/coc/extensions/node_modules/coc-prettier/node_modules/type-fest/source/set-return-type.d.ts
new file mode 100644 (file)
index 0000000..98766b1
--- /dev/null
+++ b/.config/coc/extensions/node_modules/coc-prettier/node_modules/type-fest/source/set-return-type.d.ts
@@ -0,0 +1,29 @@
+type IsAny<T> = 0 extends (1 & T) ? true : false; // https://stackoverflow.com/a/49928360/3406963
+type IsNever<T> = [T] extends [never] ? true : false;
+type IsUnknown<T> = IsNever<T> extends false ? T extends unknown ? unknown extends T ? IsAny<T> extends false ? true : false : false : false : false;
+
+/**
+Create a function type with a return type of your choice and the same parameters as the given function type.
+
+Use-case: You want to define a wrapped function that returns something different while receiving the same parameters. For example, you might want to wrap a function that can throw an error into one that will return `undefined` instead.
+
+@example
+```
+import {SetReturnType} from 'type-fest';
+
+type MyFunctionThatCanThrow = (foo: SomeType, bar: unknown) => SomeOtherType;
+
+type MyWrappedFunction = SetReturnType<MyFunctionThatCanThrow, SomeOtherType | undefined>;
+//=> type MyWrappedFunction = (foo: SomeType, bar: unknown) => SomeOtherType | undefined;
+```
+*/
+export type SetReturnType<Fn extends (...args: any[]) => any, TypeToReturn> =
+       // Just using `Parameters<Fn>` isn't ideal because it doesn't handle the `this` fake parameter.
+       Fn extends (this: infer ThisArg, ...args: infer Arguments) => any ? (
+               // If a function did not specify the `this` fake parameter, it will be inferred to `unknown`.
+               // We want to detect this situation just to display a friendlier type upon hovering on an IntelliSense-powered IDE.
+               IsUnknown<ThisArg> extends true ? (...args: Arguments) => TypeToReturn : (this: ThisArg, ...args: Arguments) => TypeToReturn
+       ) : (
+               // This part should be unreachable, but we make it meaningful just in case…
+               (...args: Parameters<Fn>) => TypeToReturn
+       );