docs(operators): add documentation for sample & sampleTime

src/app/team/team.module.ts

@@ -4,7 +4,7 @@ import { CommonModule } from '@angular/common';
 import {
   MatCardModule,
   MatButtonModule,
-  MatIconModule,
+  MatIconModule
 } from '@angular/material';
 
 import { TeamRoutingModule } from './team-routing.module';

src/app/team/team.service.spec.ts

@@ -9,7 +9,10 @@ describe('TeamService', () => {
     });
   });
 
-  it('should be created', inject([TeamService], (service: TeamService) => {
-    expect(service).toBeTruthy();
-  }));
+  it(
+    'should be created',
+    inject([TeamService], (service: TeamService) => {
+      expect(service).toBeTruthy();
+    })
+  );
 });

src/operator-docs/filtering/index.ts

@@ -6,6 +6,7 @@ import { first } from './first';
 import { ignoreElements } from './ignoreElements';
 import { last } from './last';
 import { sample } from './sample';
+import { sampleTime } from './sampleTime';
 import { single } from './single';
 import { skip } from './skip';
 import { skipUntil } from './skipUntil';
@@ -25,6 +26,7 @@ export const FILTERING_OPERATORS = [
   ignoreElements,
   last,
   sample,
+  sampleTime,
   single,
   skip,
   skipUntil,

src/operator-docs/filtering/sample.ts

@@ -19,19 +19,22 @@ export const sample: OperatorDoc = {
     extras: [
       {
         type: 'Tip',
-        text: `It's like sampleTime, but samples whenever the notifier Observable emits something.`
+        text: `
+          It's like <a href="#/operators/sampleTime" class="markdown-code">sampleTime</a>,
+          but samples whenever the notifier Observable emits something.
+        `
       }
     ]
   },
   walkthrough: {
     description: `
       <p>
-       Whenever the notifier Observable emits a value or completes,
+       Whenever the <span class="markdown-code">notifier</span> Observable emits a value or completes,
        sample looks at the source Observable and emits whichever value it has most recently emitted since the previous sampling,
        unless the source has not emitted anything since the previous sampling.
       </p>
       <p>
-       The notifier is subscribed to as soon as the output Observable is subscribed.
+       The <span class="markdown-code">notifier</span> is subscribed to as soon as the output Observable is subscribed.
       </p>
     `
   },

src/operator-docs/filtering/sampleTime.ts

@@ -0,0 +1,83 @@
+import { OperatorDoc } from '../operator.model';
+
+export const sampleTime: OperatorDoc = {
+  name: 'sampleTime',
+  operatorType: 'filtering',
+  signature:
+    'public sampleTime(period: number, scheduler: Scheduler): Observable',
+  marbleUrl: 'http://reactivex.io/rxjs/img/sampleTime.png',
+  parameters: [
+    {
+      name: 'period',
+      type: 'number',
+      attribute: '',
+      description: `The sampling period expressed in milliseconds or the time unit determined internally by the optional scheduler.`
+    },
+    {
+      name: 'scheduler',
+      type: 'Scheduler',
+      attribute: 'optional default: async',
+      description: `The IScheduler to use for managing the timers that handle the sampling.`
+    }
+  ],
+  shortDescription: {
+    description: `Emits the most recently emitted value from the source Observable within periodic time intervals.`,
+    extras: [
+      {
+        type: 'Tip',
+        text: `Samples the source Observable at periodic time intervals, emitting what it samples.`
+      }
+    ]
+  },
+  walkthrough: {
+    description: `
+    <p>
+    <span class="markdown-code">sampleTime</span> periodically looks at the source
+    Observable and emits whichever value it has most recently emitted since the previous
+    sampling, unless the source has not emitted anything since the previous sampling.
+    The sampling happens periodically in time every <span class="markdown-code">period</span>
+    milliseconds (or the time unit defined by the optional <span class="markdown-code">scheduler</span> argument).
+    The sampling starts as soon as the output Observable is subscribed.
+    </p>
+    `
+  },
+  examples: [
+    {
+      name: 'Every second, emit the most recent click at most once',
+      code: `
+            import { fromEvent } from "rxjs/observable/fromEvent";
+            import { sampleTime } from "rxjs/operators";
+
+            const clicks = fromEvent(document, "click");
+            const result = clicks.pipe(sampleTime(1000));
+            result.subscribe(x => console.log(x));
+
+            /*
+            Example console output
+            [object MouseEvent] {
+              altKey: false,
+              AT_TARGET: 2,
+              bubbles: true,
+              BUBBLING_PHASE: 3,
+              button: 0,
+              buttons: 0,
+              cancelable: true,
+              ....            //Entire object properties
+            }
+            */
+      `,
+      externalLink: {
+        platform: 'JSBin',
+        url: 'http://jsbin.com/hohulon/embed?js,console,output'
+      }
+    }
+  ],
+  relatedOperators: [
+    'auditTime',
+    'debounceTime',
+    'delay',
+    'sample',
+    'throttleTime'
+  ],
+  additionalResources: []
+};