docs: remove packageDocumentation and switch internalapi to internal

Author: christopherthielen

src/directives/directives.ts

@@ -1,14 +1,3 @@
-/**
- * The UI-Router for Angular directives:
- *
- * - [[UIView]]: A viewport for routed components
- * - [[UISref]]: A state ref to a target state; navigates when clicked
- * - [[UISrefActive]]: (and `UISrefActiveEq`) Adds a css class when a UISref's target state (or a child state) is active
- *
- * @ng2api
- * @preferred
- * @module directives
- */ /** */
 import { UISref, AnchorUISref } from './uiSref';
 import { UISrefActive } from './uiSrefActive';
 import { UIView } from './uiView';
@@ -19,12 +8,12 @@ export * from './uiSref';
 export * from './uiSrefStatus';
 export * from './uiSrefActive';
 
-/** @internalapi */
+/** @internal */
 export const _UIROUTER_DIRECTIVES = [UISref, AnchorUISref, UIView, UISrefActive, UISrefStatus];
 
 /**
  * References to the UI-Router directive classes, for use within a @Component's `directives:` property
  * @deprecated use [[UIRouterModule]]
- * @internalapi
+ * @internal
  */
 export const UIROUTER_DIRECTIVES = _UIROUTER_DIRECTIVES;

src/directives/uiSref.ts

@@ -1,5 +1,3 @@
-/** @ng2api @module directives */
-/** */
 import { UIRouter, extend, Obj, TransitionOptions, TargetState, isNumber } from '@uirouter/core';
 import {
   Directive,
@@ -16,7 +14,7 @@ import { UIView, ParentUIViewInject } from './uiView';
 import { ReplaySubject, Subscription } from 'rxjs';
 
 /**
- * @internalapi
+ * @internal
  * # blah blah blah
  */
 @Directive({ selector: 'a[uiSref]' })
@@ -113,11 +111,11 @@ export class UISref implements OnChanges {
    */
   public targetState$ = new ReplaySubject<TargetState>(1);
 
-  /** @internalapi */ private _emit = false;
-  /** @internalapi */ private _statesSub: Subscription;
-  /** @internalapi */ private _router: UIRouter;
-  /** @internalapi */ private _anchorUISref: AnchorUISref;
-  /** @internalapi */ private _parent: ParentUIViewInject;
+  /** @internal */ private _emit = false;
+  /** @internal */ private _statesSub: Subscription;
+  /** @internal */ private _router: UIRouter;
+  /** @internal */ private _anchorUISref: AnchorUISref;
+  /** @internal */ private _parent: ParentUIViewInject;
 
   constructor(
     _router: UIRouter,
@@ -131,17 +129,17 @@ export class UISref implements OnChanges {
     this._statesSub = _router.globals.states$.subscribe(() => this.update());
   }
 
-  /** @internalapi */
+  /** @internal */
   set uiSref(val: string) {
     this.state = val;
     this.update();
   }
-  /** @internalapi */
+  /** @internal */
   set uiParams(val: Obj) {
     this.params = val;
     this.update();
   }
-  /** @internalapi */
+  /** @internal */
   set uiOptions(val: TransitionOptions) {
     this.options = val;
     this.update();

src/directives/uiSrefActive.ts

@@ -1,4 +1,3 @@
-/** @ng2api @module directives */ /** */
 import { Directive, Input, ElementRef, Host, Renderer2 } from '@angular/core';
 import { UISrefStatus, SrefStatus } from './uiSrefStatus';
 import { Subscription } from 'rxjs';
@@ -100,14 +99,14 @@ export class UISrefActive {
   private _subscription: Subscription;
   constructor(uiSrefStatus: UISrefStatus, rnd: Renderer2, @Host() host: ElementRef) {
     this._subscription = uiSrefStatus.uiSrefStatus.subscribe((next: SrefStatus) => {
-      this._classes.forEach(cls => {
+      this._classes.forEach((cls) => {
         if (next.active) {
           rnd.addClass(host.nativeElement, cls);
         } else {
           rnd.removeClass(host.nativeElement, cls);
         }
       });
-      this._classesEq.forEach(cls => {
+      this._classesEq.forEach((cls) => {
         if (next.exact) {
           rnd.addClass(host.nativeElement, cls);
         } else {

src/directives/uiSrefStatus.ts

@@ -1,5 +1,3 @@
-/** @ng2api @module directives */
-/** */
 import { Directive, Output, EventEmitter, ContentChildren, QueryList, Host, Self, Optional } from '@angular/core';
 import { UISref } from './uiSref';
 import {
@@ -21,7 +19,7 @@ import {
 import { Subscription, Observable, BehaviorSubject, of, from, combineLatest, concat } from 'rxjs';
 import { switchMap, map, tap } from 'rxjs/operators';
 
-/** @internalapi */
+/** @internal */
 interface TransEvt {
   evt: string;
   trans: Transition;
@@ -43,7 +41,7 @@ export interface SrefStatus {
   targetStates: TargetState[];
 }
 
-/** @internalapi */
+/** @internal */
 const inactiveStatus: SrefStatus = {
   active: false,
   exact: false,
@@ -58,15 +56,15 @@ const inactiveStatus: SrefStatus = {
  * The predicate returns true when the target state (and param values)
  * match the (tail of) the path, and the path's param values
  *
- * @internalapi
+ * @internal
  */
 const pathMatches = (target: TargetState): Predicate<PathNode[]> => {
   if (!target.exists()) return () => false;
   const state: StateObject = target.$state();
   const targetParamVals = target.params();
   const targetPath: PathNode[] = PathUtils.buildPath(target);
   const paramSchema: Param[] = targetPath
-    .map(node => node.paramSchema)
+    .map((node) => node.paramSchema)
     .reduce(unnestR, [])
     .filter((param: Param) => targetParamVals.hasOwnProperty(param.id));
 
@@ -83,10 +81,10 @@ const pathMatches = (target: TargetState): Predicate<PathNode[]> => {
  * Expands the path to [c], [c, d]
  * Then appends each to [a,b,] and returns: [a, b, c], [a, b, c, d]
  *
- * @internalapi
+ * @internal
  */
 function spreadToSubPaths(basePath: PathNode[], appendPath: PathNode[]): PathNode[][] {
-  return appendPath.map(node => basePath.concat(PathUtils.subPath(appendPath, n => n.state === node.state)));
+  return appendPath.map((node) => basePath.concat(PathUtils.subPath(appendPath, (n) => n.state === node.state)));
 }
 
 /**
@@ -95,7 +93,7 @@ function spreadToSubPaths(basePath: PathNode[], appendPath: PathNode[]): PathNod
  * which represents the current status of that Sref:
  * active, activeEq (exact match), entering, exiting
  *
- * @internalapi
+ * @internal
  */
 function getSrefStatus(event: TransEvt, srefTarget: TargetState): SrefStatus {
   const pathMatchesTarget = pathMatches(srefTarget);
@@ -105,22 +103,13 @@ function getSrefStatus(event: TransEvt, srefTarget: TargetState): SrefStatus {
   const isSuccessEvent = event.evt === 'success';
   const activePath: PathNode[] = isSuccessEvent ? tc.to : tc.from;
 
-  const isActive = () =>
-    spreadToSubPaths([], activePath)
-      .map(pathMatchesTarget)
-      .reduce(anyTrueR, false);
+  const isActive = () => spreadToSubPaths([], activePath).map(pathMatchesTarget).reduce(anyTrueR, false);
 
   const isExact = () => pathMatchesTarget(activePath);
 
-  const isEntering = () =>
-    spreadToSubPaths(tc.retained, tc.entering)
-      .map(pathMatchesTarget)
-      .reduce(anyTrueR, false);
+  const isEntering = () => spreadToSubPaths(tc.retained, tc.entering).map(pathMatchesTarget).reduce(anyTrueR, false);
 
-  const isExiting = () =>
-    spreadToSubPaths(tc.retained, tc.exiting)
-      .map(pathMatchesTarget)
-      .reduce(anyTrueR, false);
+  const isExiting = () => spreadToSubPaths(tc.retained, tc.exiting).map(pathMatchesTarget).reduce(anyTrueR, false);
 
   return {
     active: isActive(),
@@ -131,7 +120,7 @@ function getSrefStatus(event: TransEvt, srefTarget: TargetState): SrefStatus {
   } as SrefStatus;
 }
 
-/** @internalapi */
+/** @internal */
 function mergeSrefStatus(left: SrefStatus, right: SrefStatus): SrefStatus {
   return {
     active: left.active || right.active,
@@ -204,11 +193,11 @@ export class UISrefStatus {
   /** The current status */
   status: SrefStatus;
 
-  /** @internalapi */ private _subscription: Subscription;
-  /** @internalapi */ private _srefChangesSub: Subscription;
-  /** @internalapi */ private _srefs$: BehaviorSubject<UISref[]>;
-  /** @internalapi */ private _globals: UIRouterGlobals;
-  /** @internalapi */ private _hostUiSref: UISref;
+  /** @internal */ private _subscription: Subscription;
+  /** @internal */ private _srefChangesSub: Subscription;
+  /** @internal */ private _srefs$: BehaviorSubject<UISref[]>;
+  /** @internal */ private _globals: UIRouterGlobals;
+  /** @internal */ private _hostUiSref: UISref;
   constructor(@Host() @Self() @Optional() _hostUiSref: UISref, _globals: UIRouterGlobals) {
     this._globals = _globals;
     this._hostUiSref = _hostUiSref;
@@ -223,25 +212,25 @@ export class UISrefStatus {
         const event = (evt: string) => ({ evt, trans } as TransEvt);
 
         const transStart$ = of(event('start'));
-        const transResult = trans.promise.then(() => event('success'), () => event('error'));
+        const transResult = trans.promise.then(
+          () => event('success'),
+          () => event('error')
+        );
         const transFinish$ = from(transResult);
 
         return concat(transStart$, transFinish$);
       })
     );
 
     const withHostSref = (childrenSrefs: UISref[]) =>
-      childrenSrefs
-        .concat(this._hostUiSref)
-        .filter(identity)
-        .reduce(uniqR, []);
+      childrenSrefs.concat(this._hostUiSref).filter(identity).reduce(uniqR, []);
 
     // Watch the @ContentChildren UISref[] components and get their target states
     this._srefs$ = new BehaviorSubject(withHostSref(this._srefs.toArray()));
-    this._srefChangesSub = this._srefs.changes.subscribe(srefs => this._srefs$.next(withHostSref(srefs)));
+    this._srefChangesSub = this._srefs.changes.subscribe((srefs) => this._srefs$.next(withHostSref(srefs)));
 
     const targetStates$: Observable<TargetState[]> = this._srefs$.pipe(
-      switchMap((srefs: UISref[]) => combineLatest<TargetState[]>(srefs.map(sref => sref.targetState$)))
+      switchMap((srefs: UISref[]) => combineLatest<TargetState[]>(srefs.map((sref) => sref.targetState$)))
     );
 
     // Calculate the status of each UISref based on the transition event.
@@ -251,7 +240,7 @@ export class UISrefStatus {
         switchMap((evt: TransEvt) => {
           return targetStates$.pipe(
             map((targets: TargetState[]) => {
-              const statuses: SrefStatus[] = targets.map(target => getSrefStatus(evt, target));
+              const statuses: SrefStatus[] = targets.map((target) => getSrefStatus(evt, target));
               return statuses.reduce(mergeSrefStatus);
             })
           );

src/directives/uiView.ts

@@ -1,5 +1,3 @@
-/** @ng2api @module directives */
-/** */
 import {
   Component,
   ComponentFactory,
@@ -40,13 +38,13 @@ import { MergeInjector } from '../mergeInjector';
 /** @hidden */
 let id = 0;
 
-/** @internalapi These are provide()d as the string UIView.PARENT_INJECT */
+/** @internal These are provide()d as the string UIView.PARENT_INJECT */
 export interface ParentUIViewInject {
   context: ViewContext;
   fqn: string;
 }
 
-/** @internalapi */
+/** @internal */
 interface InputMapping {
   token: string;
   prop: string;
@@ -58,10 +56,10 @@ interface InputMapping {
  * - @Input('foo') _foo
  * - `inputs: ['foo']`
  *
- * @internalapi
+ * @internal
  */
 const ng2ComponentInputs = (factory: ComponentFactory<any>): InputMapping[] => {
-  return factory.inputs.map(input => ({ prop: input.propName, token: input.templateName }));
+  return factory.inputs.map((input) => ({ prop: input.propName, token: input.templateName }));
 };
 
 /**
@@ -172,11 +170,11 @@ export class UIView implements OnInit, OnDestroy {
       config: undefined,
     };
 
-    this._deregisterUiCanExitHook = router.transitionService.onBefore({}, trans => {
+    this._deregisterUiCanExitHook = router.transitionService.onBefore({}, (trans) => {
       return this._invokeUiCanExitHook(trans);
     });
 
-    this._deregisterUiOnParamsChangedHook = router.transitionService.onSuccess({}, trans =>
+    this._deregisterUiOnParamsChangedHook = router.transitionService.onSuccess({}, (trans) =>
       this._invokeUiOnParamsChangedHook(trans)
     );
 
@@ -199,7 +197,7 @@ export class UIView implements OnInit, OnDestroy {
       const state: StateDeclaration = this.state;
 
       if (trans.exiting().indexOf(state) !== -1) {
-        trans.onStart({}, function() {
+        trans.onStart({}, function () {
           return uiCanExitFn.call(instance, trans);
         });
       }
@@ -226,14 +224,8 @@ export class UIView implements OnInit, OnDestroy {
       const toParams: { [paramName: string]: any } = $transition$.params('to');
       const fromParams: { [paramName: string]: any } = $transition$.params('from');
       const getNodeSchema = (node: PathNode) => node.paramSchema;
-      const toSchema: Param[] = $transition$
-        .treeChanges('to')
-        .map(getNodeSchema)
-        .reduce(unnestR, []);
-      const fromSchema: Param[] = $transition$
-        .treeChanges('from')
-        .map(getNodeSchema)
-        .reduce(unnestR, []);
+      const toSchema: Param[] = $transition$.treeChanges('to').map(getNodeSchema).reduce(unnestR, []);
+      const fromSchema: Param[] = $transition$.treeChanges('from').map(getNodeSchema).reduce(unnestR, []);
 
       // Find the to params that have different values than the from params
       const changedToParams = toSchema.filter((param: Param) => {
@@ -243,7 +235,7 @@ export class UIView implements OnInit, OnDestroy {
 
       // Only trigger callback if a to param has changed or is new
       if (changedToParams.length) {
-        const changedKeys: string[] = changedToParams.map(x => x.id);
+        const changedKeys: string[] = changedToParams.map((x) => x.id);
         // Filter the params to only changed/new to params.  `$transition$.params()` may be used to get all params.
         const newValues = filter(toParams, (val, key) => changedKeys.indexOf(key) !== -1);
         instance.uiOnParamsChanged(newValues, $transition$);
@@ -321,10 +313,10 @@ export class UIView implements OnInit, OnDestroy {
     // Map resolves to "useValue: providers"
     const resolvables = context
       .getTokens()
-      .map(token => context.getResolvable(token))
-      .filter(r => r.resolved);
+      .map((token) => context.getResolvable(token))
+      .filter((r) => r.resolved);
 
-    const newProviders = resolvables.map(r => ({ provide: r.token, useValue: context.injector().get(r.token) }));
+    const newProviders = resolvables.map((r) => ({ provide: r.token, useValue: context.injector().get(r.token) }));
 
     const parentInject = { context: this._uiViewData.config.viewDecl.$context, fqn: this._uiViewData.fqn };
     newProviders.push({ provide: UIView.PARENT_INJECT, useValue: parentInject });
@@ -349,7 +341,7 @@ export class UIView implements OnInit, OnDestroy {
     // Returns the actual component property for a renamed an input renamed using `@Input('foo') _foo`.
     // return the `_foo` property
     const renamedInputProp = (prop: string) => {
-      const input = factory.inputs.find(i => i.templateName === prop);
+      const input = factory.inputs.find((i) => i.templateName === prop);
       return (input && input.propName) || prop;
     };
 
@@ -360,7 +352,7 @@ export class UIView implements OnInit, OnDestroy {
     );
 
     // Supply resolve data to matching @Input('prop') or inputs: ['prop']
-    const implicitInputTuples = ng2ComponentInputs(factory).filter(tuple => !inArray(explicitBoundProps, tuple.prop));
+    const implicitInputTuples = ng2ComponentInputs(factory).filter((tuple) => !inArray(explicitBoundProps, tuple.prop));
 
     const addResolvable = (tuple: InputMapping) => ({
       prop: tuple.prop,
@@ -372,8 +364,8 @@ export class UIView implements OnInit, OnDestroy {
     explicitInputTuples
       .concat(implicitInputTuples)
       .map(addResolvable)
-      .filter(tuple => tuple.resolvable && tuple.resolvable.resolved)
-      .forEach(tuple => {
+      .filter((tuple) => tuple.resolvable && tuple.resolvable.resolved)
+      .forEach((tuple) => {
         component[tuple.prop] = injector.get(tuple.resolvable.token);
       });
   }

src/index.ts

@@ -1,5 +1,3 @@
-/** @ng2api @module ng2 */ /** for typedoc */
-
 export * from './interface';
 export * from './providers';
 export * from './uiRouterNgModule';