Clean up public API

Author: clbond

index.d.ts

@@ -9,63 +9,78 @@ declare namespace 'ng2-redux-form' {
   export const provideFormConnect: <T>(arg: Store<T> | NgRedux<T>) => Provider[];
 
   export function composeReducers<State>(
-      ...reducers: (<A extends Action>(state: State, action: A) => State)[]) =>
-    <A extends Action>(state: State, action: A) => State;
+    ...reducers: (<A extends Action>(state: State, action: A) => State)[]) =>
+  <A extends Action>(state: State, action: A) => State;
 
   export class Connect<RootState> {
-      private children;
-      private store;
-      private form;
-      connect: () => (string | string[]) | string | string[];
-      private stateSubscription;
-      private formSubscription;
-      constructor(children: QueryList<NgControl>, store: FormStore<RootState>, form: NgForm);
-      _parent: NgForm;
-      path: string[];
-      ngOnDestroy(): void;
-      private ngAfterViewInit();
-      private ngAfterContentInit();
-      protected resetState(): void;
-      protected publish(value: any): void;
-      protected getState(): RootState;
+    /// The path to the piece of state that this form is connecting to
+    connect: () => (string | string[]) | string | string[];
+
+    /// The control path of this directive (up to the root form)
+    path: string[];
+
+    constructor(children: QueryList<NgControl>, store: FormStore<RootState>, form: NgForm);
+
+    /// Update the form models with the latest state from the {@link AbstractStore}
+    protected resetState(): void;
+
+    /// Publish new form input values to the store
+    protected publish<T>(value: T): void;
   }
 
   export class FormException extends Error {}
 
   export function defaultFormReducer<RootState>(
-      initialState?: RootState | Iterable.Keyed<string, any>) =>
-    (state: RootState | Iterable.Keyed<string, any>, action: Redux.Action & {payload?}) => any;
+    initialState?: RootState | Iterable.Keyed<string, any>) =>
+  (state: RootState | Iterable.Keyed<string, any>, action: Redux.Action & {payload?}) => any;
 
+  /// The store you provide in your call to {@link provideFormConnect} must conform to the
+  /// contract described by AbstractStore. Both NgRedux and redux.Store conform. If you
+  /// wish to supply a store that is neither an NgRedux store or a redux store, you can do
+  /// it as long as your custom store is the same shape as AbstractStore<RootState>. The
+  /// type argument of AbstractStore is your root application state interface.
   export interface AbstractStore<RootState> {
-      dispatch(action: Action & {payload?}): void;
-      getState(): RootState;
-      subscribe(fn: (state: RootState) => void): Redux.Unsubscribe;
-  }
+    /// Dispatch an action to the store
+    dispatch(action: Action & {payload?}): void;
 
-  export const FORM_CHANGED: string;
+    /// Get current application state
+    getState(): RootState;
 
-  export class FormStore<RootState> {
-      private store;
-      constructor(store: AbstractStore<RootState>);
-      getState(): RootState;
-      subscribe(fn: (state: RootState) => void): Redux.Unsubscribe;
-      valueChanged<T>(path: string[], form: NgForm, value: T): void;
+    /// Subscribe to store changes
+    subscribe(fn: (state: RootState) => void): Redux.Unsubscribe;
   }
 
+  /// This is the action dispatched when form values change.
+  export const FORM_CHANGED: string;
+
   export interface Operations<T> {
-      clone(): T;
-      update(key: number | string, value: T): any;
+    /// Clone this object
+    clone(): T;
+
+    /// Merge the contents of {@link value} with this object ({@link key} is optional)
+    merge(key: number | string, value: T): any;
+
+    /// Update the values of this object with {@link value}
+    update(key: number | string, value: T): any;
   }
 
   export interface TraverseCallback {
-      (parent: any, key: number | string, remainingPath: string[], value?: any): any;
+    (parent: any, key: number | string, remainingPath: string[], value?: any): any;
   }
 
+  /// Methods to extract and assign state. Use the {@link inspect} method to retrieve an
+  /// {@link Operations<T>} object that you can use to clone, merge or update a state
+  /// object. The primary feature of {@link State} is that it works with objects of any
+  /// type: Map, WeakMap, Set, WeakSet, ImmutableJS, and any. Your state can mix and
+  /// match these types in any way you like and the assign/get operations will still work.
+  /// You could have a Map nested inside an Immutable map nested inside of an array,
+  /// for example. The {@param path} argument specifies the path that will be taken when
+  /// doing these operations.
   export abstract class State {
-      static traverse<State>(state: State, path: string[], fn?: TraverseCallback): State;
-      static get<State>(state: State, path: string[]): any;
-      static assign<State>(state: State, path: string[], value?: any): any;
-      static inspect<K>(object: K): Operations<K>;
-      static empty(value: any): boolean;
+    static traverse<State>(state: State, path: string[], fn?: TraverseCallback): State;
+    static get<State>(state: State, path: string[]): any;
+    static assign<State>(state: State, path: string[], value): any;
+    static inspect<K>(object: K): Operations<K>;
+    static empty(value: any): boolean;
   }
 }

package.json

@@ -63,5 +63,5 @@
     "typings": "rimraf typings && typings install"
   },
   "main": "dist/main.js",
-  "typings": "dist/source/index.d.ts"
+  "typings": "index.d.ts"
 }

source/connect.ts

@@ -40,10 +40,6 @@ export class Connect<RootState> {
     });
   }
 
-  get _parent() {
-    return this.form;
-  }
-
   public get path(): string[] {
     const path = typeof this.connect === 'function'
       ? this.connect()