done with chapter 8

Author: jinnatul

README.md

@@ -59,4 +59,10 @@
   - [Section 7.5: Accessors](/book_pages/chapter7/section7.5.md)
   - [Section 7.6: Transpilation](/book_pages/chapter7/section7.6.md)
   - [Section 7.7: Monkey patch a function into an existing class](/book_pages/chapter7/section7.7.md)
+
+* Chapter 8: Class Decorator
+
+  - [Section 8.1: Generating metadata using a class decorator](/book_pages/chapter8/section8.1.md)
+  - [Section 8.2: Passing arguments to a class decorator](/book_pages/chapter8/section8.2.md)
+  - [Section 8.3: Basic class decorator](/book_pages/chapter8/section8.3.md)
 

book_pages/chapter8/section8.1.md

@@ -0,0 +1,46 @@
+# Section 8.1: Generating metadata using a class decorator
+
+This time we are going to declare a class decorator that will add some metadata to a class when we 
+applied to it:
+```ts
+function addMetadata(target: any) {
+  // Add some metadata
+  target.__customMetadata = {
+    someKey: "someValue"
+  };
+  // Return target
+  return target;
+}
+
+// We can then apply the class decorator:
+@addMetadata
+class Person {
+  private _name: string;
+  public constructor(name: string) {
+    this._name = name;
+  }
+  public greet() {
+    return this._name;
+  }
+}
+
+function getMetadataFromClass(target: any) {
+  return target.__customMetadata;
+}
+
+console.log(getMetadataFromClass(Person));
+```
+
+The decorator is applied when the class is declared not when we create instances of the class. This means 
+that the metadata is shared across all the instances of a class:
+```ts
+function getMetadataFromInstance(target: any) {
+  return target.constructor.__customMetadata;
+}
+
+let person1 = new Person("John");
+let person2 = new Person("Lisa");
+
+console.log(getMetadataFromInstance(person1));
+console.log(getMetadataFromInstance(person2));
+```

book_pages/chapter8/section8.2.md

@@ -0,0 +1,41 @@
+# Section 8.2: Passing arguments to a class decorator
+
+We can wrap a class decorator with another function to allow customization:
+```ts
+function addMetadata(metadata: any) {
+  return function log(target: any) {
+    // Add metadata
+    target.__customMetadata = metadata;
+    
+    // Return target
+    return target;
+  }
+}
+```
+The addMetadata takes some arguments used as configuration and then returns an unnamed function which is 
+the actual decorator. In the decorator we can access the arguments because there is a closure in place.
+We can then invoke the decorator passing some configuration values:
+```ts
+@addMetadata({ guid: "417c6ec7-ec05-4954-a3c6-73a0d7f9f5bf" })
+class Person {
+  private _name: string;
+
+  public constructor(name: string) {
+    this._name = name;
+  }
+
+  public greet() {
+    return this._name;
+  }
+}
+
+// We can use the following function to access the generated metadata:
+function getMetadataFromClass(target: any) {
+  return target.__customMetadata;
+}
+
+console.log(getMetadataFromInstance(Person));
+
+// If everything went right the console should display:
+{ guid: "417c6ec7-ec05-4954-a3c6-73a0d7f9f5bf" }
+```

book_pages/chapter8/section8.3.md

@@ -0,0 +1,27 @@
+# Section 8.3: Basic class decorator
+
+A class decorator is just a function that takes the class as its only argument and returns it after doing 
+something with it:
+```ts
+function myClassDecorator<T>(target: T) {
+  // Do something with target
+  console.log(target);
+
+  // Return target
+  return target;
+}
+
+// We can then apply the class decorator to a class:
+@myClassDecorator
+class Person {
+  private _name: string;
+
+  public constructor(name: string) {
+    this._name = name;
+  }
+
+  public greet() {
+    return this._name;
+  }
+}
+```