feat(material-experimental/mdc-slider): add skeleton code for MatSlider

* add method stubs for MDCSliderAdapter implementation
* add MDCSliderFoundation class variable to MatSlider

Author: wagnermaciel

src/material-experimental/mdc-slider/slider.ts

@@ -6,13 +6,162 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
-import {ChangeDetectionStrategy, Component, ViewEncapsulation} from '@angular/core';
+import {
+  AfterViewInit,
+  ChangeDetectionStrategy,
+  Component,
+  OnDestroy,
+  ViewEncapsulation,
+} from '@angular/core';
+import {SpecificEventListener, EventType} from '@material/base';
+import {
+  MDCSliderAdapter,
+  MDCSliderFoundation,
+  Thumb,
+  TickMark,
+} from '@material/slider';
 
+/**
+ * Allows users to select from a range of values by moving the slider thumb. It is similar in
+ * behavior to the native `<input type="range">` element.
+ */
 @Component({
   selector: 'mat-slider',
   templateUrl: 'slider.html',
   styleUrls: ['slider.css'],
   changeDetection: ChangeDetectionStrategy.OnPush,
   encapsulation: ViewEncapsulation.None,
 })
-export class MatSlider {}
+export class MatSlider {
+  /** Instance of the MDC slider foundation for this slider. */
+  private _foundation = new MDCSliderFoundation(new SliderAdapter());
+}
+
+class SliderAdapter implements MDCSliderAdapter {
+  constructor() {}
+  hasClass(className: string): boolean {
+    throw new Error('Method not implemented.');
+  }
+  addClass(className: string): void {
+    throw new Error('Method not implemented.');
+  }
+  removeClass(className: string): void {
+    throw new Error('Method not implemented.');
+  }
+  getAttribute(attribute: string): string | null {
+    throw new Error('Method not implemented.');
+  }
+  addThumbClass(className: string, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  removeThumbClass(className: string, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  getInputValue(thumb: Thumb): string {
+    throw new Error('Method not implemented.');
+  }
+  setInputValue(value: string, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  getInputAttribute(attribute: string, thumb: Thumb): string | null {
+    throw new Error('Method not implemented.');
+  }
+  setInputAttribute(attribute: string, value: string, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  removeInputAttribute(attribute: string, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  focusInput(thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  isInputFocused(thumb: Thumb): boolean {
+    throw new Error('Method not implemented.');
+  }
+  getThumbKnobWidth(thumb: Thumb): number {
+    throw new Error('Method not implemented.');
+  }
+  getThumbBoundingClientRect(thumb: Thumb): ClientRect {
+    throw new Error('Method not implemented.');
+  }
+  getBoundingClientRect(): ClientRect {
+    throw new Error('Method not implemented.');
+  }
+  isRTL(): boolean {
+    throw new Error('Method not implemented.');
+  }
+  setThumbStyleProperty(propertyName: string, value: string, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  removeThumbStyleProperty(propertyName: string, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  setTrackActiveStyleProperty(propertyName: string, value: string): void {
+    throw new Error('Method not implemented.');
+  }
+  removeTrackActiveStyleProperty(propertyName: string): void {
+    throw new Error('Method not implemented.');
+  }
+  setValueIndicatorText(value: number, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  getValueToAriaValueTextFn(): ((value: number) => string) | null {
+    throw new Error('Method not implemented.');
+  }
+  updateTickMarks(tickMarks: TickMark[]): void {
+    throw new Error('Method not implemented.');
+  }
+  setPointerCapture(pointerId: number): void {
+    throw new Error('Method not implemented.');
+  }
+  emitChangeEvent(value: number, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  emitInputEvent(value: number, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  emitDragStartEvent(value: number, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  emitDragEndEvent(value: number, thumb: Thumb): void {
+    throw new Error('Method not implemented.');
+  }
+  registerEventHandler<K extends EventType>(evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  deregisterEventHandler<K extends EventType>(evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  registerThumbEventHandler<K extends EventType>
+    (thumb: Thumb, evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  deregisterThumbEventHandler<K extends EventType>
+    (thumb: Thumb, evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  registerInputEventHandler<K extends EventType>
+    (thumb: Thumb, evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  deregisterInputEventHandler<K extends EventType>
+    (thumb: Thumb, evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  registerBodyEventHandler<K extends EventType>
+    (evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  deregisterBodyEventHandler<K extends EventType>
+    (evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  registerWindowEventHandler<K extends EventType>
+    (evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+  deregisterWindowEventHandler<K extends EventType>
+    (evtType: K, handler: SpecificEventListener<K>): void {
+    throw new Error('Method not implemented.');
+  }
+}