I was doing a lot of stuff here

Author: threehams

README.md

@@ -11,17 +11,21 @@ Change an API? Change the type and you'll see everywhere you need to update. Nee
 TypeScript actively discourages highly-dynamic code, redefining variables to mean different things, and anything other than simple (property) strings for APIs. What do these look like?
 
 ```tsx
-// Dynamic code: 
+// Dynamic code:
 ```
 
-
-
 # For Site / Application Developers
 
 ## I'm trying to start with an empty object and add properties one by one, and TypeScript gives me errors no matter what I do. I've given up and `// @ts-ignore`d them.
 
 When you create an empty object, there's just no good way for TS to ensure that all properties have been added _after_ the object has already been specified. Don't worry, though - there are lots of ways to accomplish this, and one of them is very concise as well! See: [Build Up Object](examples/build-up-object.ts).
 
+## What's this `never` type?
+
+This is covered in the new handbook under the [never type](https://microsoft.github.io/TypeScript-New-Handbook/chapters/more-on-functions/#never).
+
+Additionally, arrays start out as `never[]` when the type cannot be inferred. See: [Never](examples/never.ts)
+
 ## Why isn't TypeScript showing errors on extra properties I have on an object?
 
 TypeScript has a system called "excess property checking" which is a great tradeoff between type safety and developer experience... provided you know how it works. Luckily, it's pretty simple. See: [Excess Property Checking](examples/excess-property-checking.ts).
@@ -74,7 +78,9 @@ This one trips up everyone at some point. There's an explanation at [Object.keys
 
 ## I don't control the object being used. How do I use the `object` type?
 
+## How can I tell TypeScript about a global variable that exists without using @ts-ignore or `any`?
 
+You're looking for the jargony `ambient context` and `ambient declaration`. When you put `declare` in front of a function, constant, or module, you are saying "trust me, this exists, and is of this type." This is especially confusing when looking at the differences between .d.ts and .ts files, so see [Types without implementations](examples/types-without-implementations.ts).
 
 # React-Specific Errors
 

examples/array-element-access.ts

@@ -0,0 +1,31 @@
+// This seems wrong...
+const array = [0, 1];
+array[0];
+array[1];
+array[2]; // hey! this should be an error!
+
+// but just like objects are mutable in TS, so are arrays.
+// Imagine this case:
+const pushToArray = <T>(arr: T[], element: T): T[] => {
+  arr.push(element);
+  return arr;
+};
+
+const arr = [0, 1];
+pushToArray(arr, 2); // now arr[2] exists
+arr[2]; // if TS showed an error here, it would be extremely annoying
+
+// TypeScript would have to do a lot more work to analyze your code to figure
+// out safe array access - and it's just not a common enough case to be worth
+// the cost.
+
+// However, tuple types exist, which have a known length that can never change.
+// Checking access on these is cheap, so use `as const` to change from number[]
+// (array of numbers of any length) to [number, number] (array of numbers with
+// a length of 2).
+// (you'll see the term "const context" floating around: it means "immutable")
+const tuple = [0, 1] as const;
+
+tuple[0];
+tuple[1];
+tuple[2]; // correctly an error

examples/definition-files.d.ts

@@ -0,0 +1,5 @@
+// go over what's different about .d.ts
+
+// declaration files
+
+// first: if a declaration file is within

examples/definition-files.ts

@@ -1,3 +1,4 @@
+export {};
 // https://github.com/Microsoft/TypeScript/blob/9c71eaf59040ae75343da8cdff01344020f5bba2/lib/diagnosticMessages.generated.json
 
 const doStuff = (thing: "thing" | "stuff") => {};

examples/error-codes.ts

@@ -13,7 +13,7 @@ function toStrings(arr: object[]): string[] {
       acc.push(obj.toString());
       return acc;
     },
-    [] as string[]
+    [] as string[],
   );
 }
 
@@ -32,7 +32,7 @@ interface User {
 }
 const fields = [
   { name: "name", value: "bob" },
-  { name: "phone", value: "8005552000" }
+  { name: "phone", value: "8005552000" },
 ] as const;
 
 fields.reduce<User>((acc, field) => {
@@ -42,14 +42,17 @@ fields.reduce<User>((acc, field) => {
 }, {});
 
 arr.reduce((acc, obj) => {
+  // error: No index signature with a parameter of type 'number' was found on type '{}'
   acc[obj] = true;
   return acc;
 }, {});
 
-const arrayWithNulls = [1, 2, null, undefined];
+const arrayWithNulls = [1, 2, null];
 // filter is a type guard = needs to explictly know how to remove the union
 const stillHasNulls: number[] = arrayWithNulls.filter(x => !!x);
-const withoutNulls: number[] = arrayWithNulls.filter((x): x is number => !!x);
+const withoutNulls: number[] = arrayWithNulls.filter(
+  (x): x is number => x !== null,
+);
 
 // since this is tedious, and boolean cast wipes out 0 and "" anyway:
 const filterNulls = Array.prototype.filter(item => item != null);

examples/filter-reduce.ts

@@ -44,7 +44,7 @@
 // Let's use this above:
 () => {
   type Last<TItem> = (item: TItem) => TItem;
-  const last = (item: string) => {
+  const last: Last<> = item => {
     return item[item.length - 1];
   };
 

examples/generics.ts

@@ -0,0 +1,29 @@
+export {};
+// The `never` type is a condition which should never happen.
+// This most commonly happens when a function throws an error, or when if/else/switch/case
+// runs out of options and hits an `else` or `default` case.
+
+// from: https://microsoft.github.io/TypeScript-New-Handbook/chapters/more-on-functions/#never
+function fn(x: string | number) {
+  if (typeof x === "string") {
+    // do something
+  } else if (typeof x === "number") {
+    // do something else
+  } else {
+    x; // has type 'never'!
+  }
+}
+
+function fail(msg: string): never {
+  throw new Error(msg);
+}
+
+// The other time you'll see `never` is when creating a new empty array, when
+// noImplicityAny is set to `false`. It is extremely unlikely you will see this,
+// but the type defaults to `never[]` to prevent it from being inferred as `any[]`.
+// Simple fix: give it a type, or set `noImplicitAny` to true.
+// https://github.com/microsoft/TypeScript/pull/8944
+
+const emptyArray = []; // never[]
+emptyArray.push(1); // nope!
+const emptyNumberArray: number[] = [];

examples/never.ts

@@ -95,5 +95,6 @@ const doStuffWithUnions = (data?: UnreliableUnionData) => {
 const doStuffWithDefaults = (data: UnreliableData) => {
   // "Initializer provides no value for this binding element and the binding element has no default value.ts(2525)"
   const { nullableString }: UnreliableData["mayExist"] = data.mayExist || {};
-  // This will be fixed when TypeScript 3.6 is released.
+  // This will be fixed when TypeScript 3.6 is released:
+  // https://github.com/microsoft/TypeScript/pull/31711
 };

examples/safe-property-access.ts

@@ -0,0 +1,21 @@
+export {};
+// The `void` is the absence of a type. It has one purpose: to
+// allow functions to return values which are ignored.
+// A practical use for this is an event handler which may want
+// to use a braceless arrow function.
+
+// Contrast this with `undefined`, which enforces a return statement.
+type OnMouseEnter = () => void;
+const onMouseEnter: OnMouseEnter = () => false; // fine
+const returnValue = onMouseEnter(); // returnValue === void
+
+type OnMouseLeave = () => undefined;
+const onMouseLeave: OnMouseLeave = () => false; // error: false !== undefined
+
+// Note that void is more strict when put directly on a function.
+const returnUndefined = (): undefined => {
+  return false; // error: false !== undefined
+};
+const returnVoid = (): void => {
+  return false; // error: false !== void
+};

examples/type-assertions.ts

@@ -0,0 +1,55 @@
+# Common Terms
+
+## Structural Typing
+
+## Subtype
+
+In structural typing, a type which matches another type, but contains extra properties, is considered a subtype.
+In TypeScript
+Example:
+
+```ts
+const;
+```
+
+## Excess Property Checking
+
+The
+
+## Freshness
+
+## Inference
+
+## Invariant
+
+## Type Parameter
+
+Code which can be checked at runtime.
+
+Type safe function:
+
+```tsx
+const;
+```
+
+## Type Safe
+
+# Obscure Terms
+
+## Covariant/Contravariant
+
+# Really Obscure Terms
+
+## Homomorphic
+
+## Naked Type Parameter
+
+A type parameter (see above) which is not wrapped in something like an array.
+
+Example:
+
+```ts
+// T here is any element in the array
+// T[] is the array itself
+const filter = <T>(array: T[], func: (T): boolean): T[] => {}
+```

examples/types-without-implementations.ts

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "allowJs": true,
+    "allowJs": false,
     "allowSyntheticDefaultImports": true,
     "jsx": "preserve",
     "lib": ["dom", "esnext"],