docs(operators): add documentation for sample & sampleTime

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

@@ -1,6 +1,56 @@
 import { OperatorDoc } from '../operator.model';
 
 export const sample: OperatorDoc = {
-  'name': 'sample',
-  'operatorType': 'filtering'
+  name: 'sample',
+  operatorType: 'filtering',
+  signature: 'public sample(notifier: Observable<any>): Observable<T>',
+  marbleUrl: 'http://reactivex.io/rxjs/img/sample.png',
+  parameters: [
+    {
+      name: 'notifier',
+      type: 'Observable<any>',
+      attribute: '',
+      description: `The Observable to use for sampling the source Observable.`
+    }
+  ],
+  shortDescription: {
+    description: `
+      Emits the most recently emitted value from the source Observable
+      whenever another Observable, the <span class="markdown-code">notifier</span>, emits.
+    `,
+    extras: [
+      {
+        type: 'Tip',
+        text: `It's like sampleTime, but samples whenever the notifier Observable emits something.`
+      }
+    ]
+  },
+  walkthrough: {
+    description: `
+    <p>
+      Whenever the <span class="markdown-code">notifier</span> Observable emits a value or completes,
+      <span class="markdown-code">sample</span> 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 <span class="markdown-code">notifier</span> is subscribed to as soon as the output Observable is subscribed.
+    </p>
+    `
+  },
+  examples: [
+    {
+      name: 'On every click, sample the most recent "seconds" timer',
+      code: `
+        const seconds = Rx.Observable.interval(1000);
+        const clicks = Rx.Observable.fromEvent(document, 'click');
+        const result = seconds.sample(clicks);
+        result.subscribe(x => console.log(x))
+      `,
+      externalLink: {
+        platform: 'JSBin',
+        url: 'http://jsbin.com/xapiviz/edit?js,console,output'
+      }
+    }
+  ],
+  relatedOperators: ['audit', 'debounce', 'sampleTime', 'throttle'],
+  additionalResources: []
 };

src/operator-docs/filtering/sampleTime.ts

@@ -0,0 +1,66 @@
+import { OperatorDoc } from '../operator.model';
+
+export const sampleTime: OperatorDoc = {
+  name: 'sampleTime',
+  operatorType: 'filtering',
+  signature:
+    'public sampleTime(period: number, scheduler: Scheduler): Observable<T>',
+  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: `
+            const clicks = Rx.Observable.fromEvent(document, 'click');
+            const result = clicks.sampleTime(1000);
+            result.subscribe(x => console.log(x));
+      `,
+      externalLink: {
+        platform: 'JSBin',
+        url: 'http://jsbin.com/hohulon/edit?js,console,output'
+      }
+    }
+  ],
+  relatedOperators: [
+    'auditTime',
+    'debounceTime',
+    'delay',
+    'sample',
+    'throttleTime'
+  ],
+  additionalResources: []
+};