FreeCourseSite com Udemy - Typescript The Complete Developer's Guide

1. Lesson 0. How to Get Help.mp47.19MB
2. Lesson 1. Typescript Overview.mp443.1MB
3. Lesson 10. More on Types.mp444.24MB
4. Lesson 100. When to Use Enums.mp454.83MB
5. Lesson 101. Extracting CSV Reading.mp456.42MB
6. Lesson 102. Data Types.mp419.33MB
7. Lesson 103. Converting Date Strings to Dates.mp427.46MB
8. Lesson 104. Converting Row Values.mp424.45MB
9. Lesson 105. Type Assertions.mp427.47MB
10. Lesson 106. Describing a Row with a Tuple.mp456.15MB
11. Lesson 107. Not Done with FileReader Yet!.mp427.16MB
12. Lesson 108. Understanding Refactor #1.mp432.65MB
13. Lesson 109. Creating Abstract Classes.mp433.47MB
14. Lesson 11. Examples of Types.mp421.37MB
15. Lesson 110. Variable Types with Generics.mp464.99MB
16. Lesson 111. Applying a Type to a Generic Class.mp434.73MB
17. Lesson 112. Alternate Refactor.mp432.64MB
18. Lesson 113. Interface-Based Approach.mp413.48MB
19. Lesson 114. Extracting Match References - Again!.mp420.73MB
20. Lesson 115. Transforming Data.mp421.49MB
21. Lesson 116. Updating Reader References.mp434.08MB
22. Lesson 117. Inheritance vs Composition.mp425.74MB
23. Lesson 118. More on Inheritance vs Composition.mp457.05MB
24. Lesson 119. A Huge Misconception Around Composition.mp4109.94MB
25. Lesson 12. Where Do We Use Types.mp45.94MB
26. Lesson 120. Goal Moving Forward.mp445.38MB
27. Lesson 121. A Composition-Based Approach.mp451.61MB
28. Lesson 122. Implementing an Analyzer Class.mp459.86MB
29. Lesson 123. Building the Reporter.mp443.85MB
30. Lesson 124. Putting It All Together.mp433.64MB
31. Lesson 125. Generating HTML Reports.mp438.43MB
32. Lesson 126. One Last Thing!.mp449.99MB
33. Lesson 127. Oops, My Bad.mp430.28MB
34. Lesson 128. App Wrapup.mp426.54MB
35. Lesson 129. More on Generics.mp429.5MB
36. Lesson 13. Type Annotations and Inference.mp414.58MB
37. Lesson 130. Type Inference with Generics.mp415.48MB
38. Lesson 131. Function Generics.mp436.48MB
39. Lesson 132. Generic Constraints.mp438.54MB
40. Lesson 133. App Overview.mp411.67MB
41. Lesson 134. Parcel Setup.mp410.64MB
42. Lesson 135. Framework Structure.mp462.33MB
43. Lesson 136. Designing the User.mp425.89MB
44. Lesson 137. Retrieving User Properties.mp431.9MB
45. Lesson 138. Optional Interface Properties.mp439.3MB
46. Lesson 139. An Eventing System.mp421.96MB
47. Lesson 14. Annotations with Variables.mp425.8MB
48. Lesson 140. Listener Support.mp426.8MB
49. Lesson 141. Storing Event Listeners.mp434.99MB
50. Lesson 142. Dynamic Array Creation.mp433.55MB
51. Lesson 143. Triggering Event Callbacks.mp430.08MB
52. Lesson 144. Adding JSON Server.mp447.48MB
53. Lesson 145. Understanding REST Conventions.mp454.65MB
54. Lesson 146. Adding Fetch Functionality.mp432.05MB
55. Lesson 147. Successfully Fetching Model Data.mp426.44MB
56. Lesson 148. Saving User Data.mp459.38MB
57. Lesson 149. Refactoring with Composition.mp433.39MB
58. Lesson 15. Object Literal Annotations.mp435.92MB
59. Lesson 150. Re-Integrating Eventing.mp4108.37MB
60. Lesson 151. Composition with Nested Objects.mp419.95MB
61. Lesson 152. A More Complicated Extraction.mp422.25MB
62. Lesson 153. Options for Adapting Sync.mp477.24MB
63. Lesson 154. Refactoring Sync.mp480.65MB
64. Lesson 155. Generic Constraints Around Sync.mp426.47MB
65. Lesson 156. Connecting Sync Back to User.mp434.81MB
66. Lesson 157. Optional Properties.mp457.3MB
67. Lesson 158. Extracting an Attributes Class.mp420.82MB
68. Lesson 159. The Get Method's Shortcoming.mp438.26MB
69. Lesson 16. Annotations Around Functions.mp435.84MB
70. Lesson 160. Two Important Rules.mp439.78MB
71. Lesson 161. An Advanced Generic Constraint.mp464.89MB
72. Lesson 162. Re-Integrating Attributes.mp424.53MB
73. Lesson 163. Composition is Delegation.mp431.75MB
74. Lesson 164. Reminder on Accessors.mp439.28MB
75. Lesson 165. Passthrough Methods.mp446.37MB
76. Lesson 166. A Context Issue.mp462.74MB
77. Lesson 167. Setting Data While Triggering.mp426.43MB
78. Lesson 168. Fetching User Data.mp446.48MB
79. Lesson 169. Saving Data.mp439.61MB
80. Lesson 17. Understanding Inference.mp428.06MB
81. Lesson 170. Composition vs Inheritance...Again!.mp469.66MB
82. Lesson 171. Extracting a Model Class.mp453.42MB
83. Lesson 172. Extending the User.mp449.98MB
84. Lesson 173. Final User Refactor.mp433.56MB
85. Lesson 174. Model Wrapup.mp427.11MB
86. Lesson 175. Shortened Passthrough Methods.mp443.42MB
87. Lesson 176. Users Collection.mp421.27MB
88. Lesson 177. Implementing a Users Collection.mp421.86MB
89. Lesson 178. Parsing User JSON.mp455.24MB
90. Lesson 179. Generic User Collection.mp450.41MB
91. Lesson 18. The 'Any' Type.mp453.58MB
92. Lesson 180. A Class Method for Collections.mp420.27MB
93. Lesson 181. View Classes.mp430.61MB
94. Lesson 182. Building the UserForm.mp436.61MB
95. Lesson 183. The UserForm's Render Method.mp419.58MB
96. Lesson 184. Rendering HTML.mp413.6MB
97. Lesson 185. Defining an Events Map.mp440.68MB
98. Lesson 186. Binding Event Handlers.mp459.38MB
99. Lesson 187. Adding Model Properties.mp432MB
100. Lesson 188. Binding Events on Class Name.mp442.13MB
101. Lesson 189. Adding Methods to the User.mp431.94MB
102. Lesson 19. Fixing the 'Any' Type.mp413.02MB
103. Lesson 190. Re-Rendering on Model Change.mp436.35MB
104. Lesson 191. Reading Input Text.mp434.91MB
105. Lesson 192. Strict Null Checks.mp445.3MB
106. Lesson 193. Reusable View Logic.mp4103.65MB
107. Lesson 194. Extracting a View Class.mp439.8MB
108. Lesson 195. Extending with Generic Constraints.mp4105.03MB
109. Lesson 196. Saving Data From a View.mp429.09MB
110. Lesson 197. UserEdit and UserShow.mp440.56MB
111. Lesson 198. Nesting with Regions.mp432.55MB
112. Lesson 199. Mapping Regions.mp453.31MB
113. Lesson 2. Environment Setup.mp460.05MB
114. Lesson 20. Delayed Initialization.mp421.52MB
115. Lesson 200. Testing Region Mapping.mp432.34MB
116. Lesson 201. View Nesting.mp454.39MB
117. Lesson 202. Collection Views.mp417.58MB
118. Lesson 203. CollectionView Implementation.mp4118.11MB
119. Lesson 204. App Wrapup.mp443.09MB
120. Lesson 205. Typescript with JS Libraries.mp442.43MB
121. Lesson 206. App Overview.mp421.87MB
122. Lesson 207. Project Setup.mp422.89MB
123. Lesson 208. Basic Routes with Express.mp439.18MB
124. Lesson 209. Using an Express Router.mp422.28MB
125. Lesson 21. When Inference Doesn't Work.mp428.56MB
126. Lesson 210. Parsing Form Bodies.mp437.24MB
127. Lesson 211. Why Doesn't Express Play Nicely with TS.mp496.51MB
128. Lesson 212. Issues with Type Definition Files.mp482.87MB
129. Lesson 213. Dealing with Poor Type Defs.mp444.45MB
130. Lesson 214. Wiring Up Sessions.mp468.78MB
131. Lesson 215. Checking Login Status.mp427.87MB
132. Lesson 216. Logging Out.mp48.75MB
133. Lesson 217. Protecting Routes.mp439.19MB
134. Lesson 218. A Closer Integration.mp450.37MB
135. Lesson 219. The Refactoring Process.mp424.81MB
136. Lesson 22. More on Annotations Around Functions.mp430.41MB
137. Lesson 220. Prototypes Reminder.mp462.39MB
138. Lesson 221. Decorators in Typescript.mp448.49MB
139. Lesson 222. Details on Decorators.mp454.6MB
140. Lesson 223. Property Descriptors.mp439.55MB
141. Lesson 224. Wrapping Methods with Descriptors.mp415.31MB
142. Lesson 225. Decorator Factories.mp421.9MB
143. Lesson 226. Decorators Around Properties.mp429.51MB
144. Lesson 227. More on Decorators.mp458.03MB
145. Lesson 228. A Quick Disclaimer.mp47.31MB
146. Lesson 229. Project Overview.mp471.77MB
147. Lesson 23. Inference Around Functions.mp426.22MB
148. Lesson 230. Why is This Hard.mp464.17MB
149. Lesson 231. Solution Overview.mp448.11MB
150. Lesson 232. Basics of Metadata.mp450.51MB
151. Lesson 233. Practical Metadata.mp481.27MB
152. Lesson 234. Let's Refactor!.mp438.55MB
153. Lesson 235. The 'Get' Decorator.mp427.31MB
154. Lesson 236. The Controller Decorator.mp426.47MB
155. Lesson 237. Proof of Concept.mp440.06MB
156. Lesson 238. A Few Fixups.mp459.28MB
157. Lesson 239. Defining a RouteBinder.mp441.87MB
158. Lesson 24. Annotations for Anonymous Functions.mp410.53MB
159. Lesson 240. Closed Method Sets with Enums.mp464.6MB
160. Lesson 241. Metadata Keys.mp433.38MB
161. Lesson 242. The 'Use' Decorator.mp458.59MB
162. Lesson 243. Testing Use.mp426.42MB
163. Lesson 244. Body Validators.mp449.63MB
164. Lesson 245. Automated Validation.mp431.48MB
165. Lesson 246. Testing Automated Validation.mp449.03MB
166. Lesson 247. Fixing Routes.mp454.45MB
167. Lesson 248. Using Property Descriptors for Type Checking.mp450.42MB
168. Lesson 249. App Wrapup.mp411.47MB
169. Lesson 25. Void and Never.mp417.21MB
170. Lesson 250. React and Redux Overview.mp448.5MB
171. Lesson 251. App Overview.mp414.99MB
172. Lesson 252. Generating the App.mp45.66MB
173. Lesson 253. Simple Components.mp420.8MB
174. Lesson 254. Interfaces with Props.mp422.94MB
175. Lesson 255. Handling Component State.mp418.35MB
176. Lesson 256. Confusing Component State!.mp486.48MB
177. Lesson 257. Functional Components.mp424.1MB
178. Lesson 258. Redux Setup.mp452.04MB
179. Lesson 259. Action Creators with Typescript.mp449.28MB
180. Lesson 26. Destructuring with Annotations.mp425.28MB
181. Lesson 260. Action Types Enum.mp435.76MB
182. Lesson 261. The Generic Dispatch Function.mp444.63MB
183. Lesson 262. A Reducer with Enums.mp441.47MB
184. Lesson 263. Validating Store Structure.mp435.85MB
185. Lesson 264. Connecting a Component to Redux.mp445.88MB
186. Lesson 265. Rendering a List.mp433.98MB
187. Lesson 266. Adding in Delete Functionality.mp425.85MB
188. Lesson 267. Breaking Out Action Creators.mp425.88MB
189. Lesson 268. Expressing Actions as Type Union.mp427.97MB
190. Lesson 269. Type Guards in Reducers.mp418.69MB
191. Lesson 27. Annotations Around Objects.mp441.85MB
192. Lesson 270. Again, Type Definition Files.mp422.43MB
193. Lesson 271. Tracking Loading with Component State.mp432.55MB
194. Lesson 272. App Wrapup.mp427.14MB
195. Lesson 28. Arrays in Typescript.mp423.12MB
196. Lesson 29. Why Typed Arrays.mp429.61MB
197. Lesson 3. A First App.mp425.21MB
198. Lesson 30. Multiple Types in Arrays.mp417.35MB
199. Lesson 31. When to Use Typed Arrays.mp46.02MB
200. Lesson 32. Tuples in Typescript.mp429.67MB
201. Lesson 33. Tuples in Action.mp427.25MB
202. Lesson 34. Why Tuples.mp419.25MB
203. Lesson 35. Interfaces.mp49.4MB
204. Lesson 36. Long Type Annotations.mp424.1MB
205. Lesson 37. Fixing Long Annotations with Interfaces.mp435.41MB
206. Lesson 38. Syntax Around Interfaces.mp427.24MB
207. Lesson 39. Functions in Interfaces.mp432.51MB
208. Lesson 4. Executing Typescript Code.mp423.64MB
209. Lesson 40. Code Reuse with Interfaces.mp430.48MB
210. Lesson 41. General Plan with Interfaces.mp423.76MB
211. Lesson 42. Classes.mp420.18MB
212. Lesson 43. Basic Inheritance.mp418.14MB
213. Lesson 44. Instance Method Modifiers.mp443.45MB
214. Lesson 45. Fields in Classes.mp442.29MB
215. Lesson 46. Fields with Inheritance.mp432.64MB
216. Lesson 47. Where to Use Classes.mp47.09MB
217. Lesson 48. App Overview.mp418.43MB
218. Lesson 49. Bundling with Parcel.mp425.28MB
219. Lesson 5. One Quick Change.mp420.29MB
220. Lesson 50. Project Structure.mp422.18MB
221. Lesson 51. Generating Random Data.mp432.8MB
222. Lesson 52. Type Definition Files.mp435.1MB
223. Lesson 53. Using Type Definition Files.mp448.15MB
224. Lesson 54. Export Statements inTypescript.mp431.82MB
225. Lesson 55. Defining a Company.mp430.99MB
226. Lesson 56. Adding Google Maps Support.mp452.49MB
227. Lesson 57. Google Maps Integration.mp427.13MB
228. Lesson 58. Exploring Type Definition Files.mp4110.1MB
229. Lesson 59. Hiding Functionality.mp451.76MB
230. Lesson 6. Catching Errors with Typescript.mp451.88MB
231. Lesson 60. Why Use Private Modifiers Here's Why.mp449.28MB
232. Lesson 61. Adding Markers.mp477.06MB
233. Lesson 62. Duplicate Code.mp423.52MB
234. Lesson 63. One Possible Solution.mp454.77MB
235. Lesson 64. Restricting Access with Interfaces.mp444.52MB
236. Lesson 65. Implicit Type Checks.mp427.27MB
237. Lesson 66. Showing Popup Windows.mp467.43MB
238. Lesson 67. Updating Interface Definitions.mp460.77MB
239. Lesson 68. Optional Implements Clauses.mp451.75MB
240. Lesson 69. App Wrapup.mp466.1MB
241. Lesson 7. Catching More Errors!.mp436.81MB
242. Lesson 70. App Overview.mp411.47MB
243. Lesson 71. Configuring the TS Compiler.mp439.3MB
244. Lesson 72. Concurrent Compilation and Execution.mp430.35MB
245. Lesson 73. A Simple Sorting Algorithm.mp431.86MB
246. Lesson 74. Sorter Scaffolding.mp417.07MB
247. Lesson 75. Sorting Implementation.mp435.43MB
248. Lesson 76. Two Huge Issues.mp445.43MB
249. Lesson 77. Typescript is Really Smart.mp473.07MB
250. Lesson 78. Type Guards.mp482.48MB
251. Lesson 79. Why is This Bad.mp422.57MB
252. Lesson 8. Do Not Skip - Course Overview.mp422.56MB
253. Lesson 80. Extracting Key Logic.mp465.51MB
254. Lesson 81. Separating Swapping and Comparison.mp4106.12MB
255. Lesson 82. The Big Reveal.mp437.89MB
256. Lesson 83. Interface Definition.mp438.48MB
257. Lesson 84. Sorting Arbitrary Collections.mp485.72MB
258. Lesson 85. Linked List Implementation.mp4182.37MB
259. Lesson 86. Just...One...More...Fix....mp440.82MB
260. Lesson 87. Integrating the Sort Method.mp424.41MB
261. Lesson 88. Issues with Inheritance.mp453.58MB
262. Lesson 89. Abstract Classes.mp451.2MB
263. Lesson 9. Types.mp435.66MB
264. Lesson 90. Why Use Abstract Classes.mp433.26MB
265. Lesson 91. Solving All Issues with Abstract Classes.mp440.32MB
266. Lesson 92. Interfaces vs Abstract Classes.mp427.31MB
267. Lesson 93. Project Overview.mp411.89MB
268. Lesson 94. Project Setup.mp436.04MB
269. Lesson 95. Type Definition Files - Again!.mp447.53MB
270. Lesson 96. Reading CSV Files.mp434.43MB
271. Lesson 97. Running an Analysis.mp435.28MB
272. Lesson 98. Losing Dataset Context.mp435.27MB
273. Lesson 99. Using Enums.mp442.08MB