Merge pull request #2571 from Polymer/3-0-api-links

Update API doc links

Author: Arthur Evans

app/3.0/docs/devguide/custom-css-properties.md

@@ -404,7 +404,7 @@ import '@webcomponents/shadycss/entrypoints/apply-shim.js';
 Polymer's custom property shim evaluates and applies custom property values once
 at element creation time. In order to have an element (and its subtree) re-
 evaluate custom property values due to dynamic changes such as application of
-CSS classes, call the [`updateStyles`](/3.0/docs/api/elements/Polymer.Element#method-updateStyles)
+CSS classes, call the [`updateStyles`](/3.0/docs/api/polymer-element#PolymerElement-method-updateStyles)
 method on the element. To update _all_ elements on the page, you can also call
 `Polymer.updateStyles`.
 
@@ -449,7 +449,7 @@ if (ShadyCSS) {
 ```
 
 Elements using the legacy API can use the
-[`getComputedStyleValue`](/3.0/docs/api/mixins/Polymer.LegacyElementMixin#method-getComputedStyleValue)
+[`getComputedStyleValue`](/3.0/docs/api/legacy/legacy-element-mixin#LegacyElementMixin-method-getComputedStyleValue)
 instance method instead of testing for `ShadyCSS`.
 
 ### Custom properties shim limitations
@@ -471,7 +471,7 @@ dynamism will continue to be explored.
 Only property definitions which match the element at *creation time* are applied.
 Any dynamic changes that update property values are not applied automatically. You
 can force styles to be re-evaluated by calling the
-[`updateStyles`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-updateStyles) method on a
+[`updateStyles`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-updateStyles) method on a
 Polymer element, or the global `updateStyles` function to update all element
 styles.
 

app/3.0/docs/devguide/custom-elements.md

@@ -198,7 +198,7 @@ Related topics:
 
 ### Defer non-critical work {#defer-work}
 
-When possible, defer work until after first paint. The [`render-status`](/{{{polymer_version_dir}}}/docs/api/namespaces/Polymer.RenderStatus) module provides 
+When possible, defer work until after first paint. The [`render-status`](/{{{polymer_version_dir}}}/docs/api/utils/render-status) module provides 
 an `afterNextRender` utility for this purpose. 
 
 ```js
@@ -436,7 +436,7 @@ in Document your elements.
 When creating a mixin that you intend to share with other groups or publish, a couple of additional
 steps are recommended:
 
--   Use the [`dedupingMixin`](/{{{polymer_version_dir}}}/docs/api/#function-Polymer.dedupingMixin)
+-   Use the [`dedupingMixin`](/{{{polymer_version_dir}}}/docs/api/utils/mixin#function-dedupingMixin)
     function to produce a mixin that can only be applied once.
 
 -   Define the mixin in an ES module and export it.

app/3.0/docs/devguide/data-system.md

@@ -162,8 +162,8 @@ this.push('users', { name: 'Maturin'});
 
 In some cases, you can't use the Polymer methods to mutate objects and arrays (for example, if
 you're using a third-party library). In this case, you can use  the
-[`notifyPath`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-notifyPath) and
-[`notifySplices`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-notifySplices)
+[`notifyPath`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-notifyPath) and
+[`notifySplices`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-notifySplices)
 methods to *notify* the element about changes that have **already taken place.**
 
 
@@ -196,7 +196,7 @@ If you have a data structure with multiple levels of objects and arrays, you may
 deep copy to pick up changes.
 
 If your application requires it, you can eliminate dirty-checking of objects and arrays on a
-per-element basis using the `Polymer.MutableData` mixin. This mixin may trade some performance
+per-element basis using the `MutableData` mixin. This mixin may trade some performance
 for increased ease of use. For details, see [Using the MutableData mixin](#mutable-data).
 
 Related tasks:
@@ -357,7 +357,7 @@ maintains path linkages between an array and a selected item from that array. (`
 also works when selecting multiple items from an array.)
 
 For other use cases, there's an imperative method,
-[`linkPaths`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-linkPaths) to
+[`linkPaths`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-linkPaths) to
 associate two paths. When two paths are *linked*, an [observable change](#observable-changes) to one
 path is observable on the other path, as well.
 
@@ -888,7 +888,7 @@ the following is true:
 *   You always use the Polymer data mutation methods to make granular changes.
 
 However, for apps that don't use immutable data and can't use the Polymer data methods, Polymer 3.0
-provides the [`MutableData`](/{{{polymer_version_dir}}}/docs/api/mixins/Polymer.MutableData)
+provides the [`MutableData`](/{{{polymer_version_dir}}}/docs/api/mixins/mutable-data#MutableData)
 mixin.
 
 ```js
@@ -954,7 +954,7 @@ complex reusable elements (like `dom-repeat` or `iron-list`), or for application
 that hold complex state information.
 
 Note that the `MutableData` mixin does not affect the element's shadow DOM children. **Any element
-that doesn't use the `Polymer.MutableData` mixin uses the default dirty-checking policy.**
+that doesn't use the `MutableData` mixin uses the default dirty-checking policy.**
 
 If you're using the `dom-repeat` element, you can enable mutable data mode by setting its
 `mutableData` property:
@@ -970,7 +970,7 @@ If you're using the `dom-repeat` element, you can enable mutable data mode by se
 ### Optional mutable data for reusable elements {#optional-mutable-data}
 
 If you're building a reusable element that takes structured data, you can use the
-[`Polymer.OptionalMutableData`](/{{{polymer_version_dir}}}/docs/api/mixins/Polymer.OptionalMutableData)
+[`OptionalMutableData`](/{{{polymer_version_dir}}}/docs/api/mixins/mutable-data#OptionalMutableData)
 mixin. This mixin lets the element user select `MutableData` mode by setting the `mutableData`
 property on the element.
 

app/3.0/docs/devguide/model-data.md

@@ -41,7 +41,7 @@ There are a few special types of path segments.
 
 ## Get a value by path {#get-value}
 
-Use the [`get`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-get) method to retrieve a value based on
+Use the [`get`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-get) method to retrieve a value based on
 its path.
 
 ```
@@ -54,7 +54,7 @@ var item = this.get(['myArray', 11])
 
 ## Set a property or subproperty by path {#set-path}
 
-Use the [`set`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-set) method to
+Use the [`set`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-set) method to
 make an [observable change](data-system#observable-changes) to a subproperty.
 
 ```js
@@ -206,7 +206,7 @@ a few choices:
 Whenever possible you should always use Polymer's [array mutation methods](#array-mutation).
 However, this isn't always possible. For example, you may be using a third-party library
 that does not use Polymer's array mutation methods. In these scenarios you can call
-<a href="/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-notifySplices">`notifySplices`</a>
+<a href="/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-notifySplices">`notifySplices`</a>
 after the mutations to ensure that any Polymer elements observing the array
 are properly notified of the changes.
 
@@ -225,7 +225,7 @@ object or array itself hasn't changed. For details, see [Using the MutableData m
 
 ## Batch multiple property changes {#set-property}
 
-Use [`setProperties`](/{{{polymer_version_dir}}}/docs/api/mixins/Polymer.PropertyEffects#method-setProperties)
+Use [`setProperties`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-setProperties)
 method to make a batch change to a set of properties. This ensures the property changes
 run as a coherent set.
 
@@ -248,7 +248,7 @@ this.setProperties({
 
 ## Link two paths to the same object {#linkpaths}
 
-Use the [`linkPaths`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.Element#method-linkPaths)
+Use the [`linkPaths`](/{{{polymer_version_dir}}}/docs/api/polymer-element#PolymerElement-method-linkPaths)
 method to associate two paths. Use `linkPaths` when an element has two paths that refer to the same
 object, as described in [Two paths referencing the same object](data-system#two-paths).
 

app/3.0/docs/devguide/observers.md

@@ -44,7 +44,7 @@ This allows the element to avoid running observers in the default case.
 
 Like all property effects, observers are synchronous. If the observer is likely to be invoked
 frequently, consider deferring time-consuming work, like inserting or removing DOM. For example, you
-can use the [`Polymer.Async`](/{{{polymer_version_dir}}}/docs/api/namespaces/Polymer.Async) module to defer work.
+can use the [`async`](/{{{polymer_version_dir}}}/docs/api/utils/async) module to defer work.
 
 However, if you handle a data change asynchronously, note that the parameters passed to the observer
 may not match the element's current property values.

app/3.0/docs/devguide/templates.md

@@ -386,7 +386,7 @@ static get template() {
 
 ### Forcing synchronous renders {#synchronous-renders}
 
-Call [`render`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.DomRepeat#method-render)
+Call [`render`](/{{{polymer_version_dir}}}/docs/api/elements/dom-repeat#DomRepeat-method-render)
 to force a `dom-repeat` template to synchronously render any changes to its
 data. Normally changes are batched and rendered asynchronously. Synchronous
 rendering has a performance cost, but can be useful in a few scenarios:
@@ -423,7 +423,7 @@ one of the following:
     For complex data structures, a deep clone may be required.
 
 *   If you don't have an exact set of changes, you can set the
-    [`mutableData`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.DomRepeat#property-mutableData)
+    [`mutableData`](/{{{polymer_version_dir}}}/docs/api/elements/dom-repeat#DomRepeat-property-mutableData)
     property on the `dom-repeat` to disable dirty checking on the array.
 
       ```html
@@ -448,22 +448,22 @@ By default, `dom-repeat` tries to render all of the list items at once. If
 you try to use `dom-repeat` to render a very large list of items, the UI may
 freeze while it's rendering the list. If you encounter this problem, enable
 "chunked" rendering by setting
-[`initialCount`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.DomRepeat#property-initialCount).
+[`initialCount`](/{{{polymer_version_dir}}}/docs/api/elements/dom-repeat#DomRepeat-property-initialCount).
 In chunked mode,
 `dom-repeat` renders `initialCount` items at first, then renders the rest of
 the items incrementally one chunk per animation frame. This lets the UI thread
 handle user input between chunks. You can keep track of how many items have
 been rendered with the
-[`renderedItemCount`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.DomRepeat#property-renderedItemCount)
+[`renderedItemCount`](/{{{polymer_version_dir}}}/docs/api/elements/dom-repeat#DomRepeat-property-renderedItemCount)
 read-only property.
 
 `dom-repeat` adjusts the number of items rendered in each chunk to try and
 maintain a target framerate. You can further tune rendering by setting
-[`targetFramerate`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.DomRepeat#property-targetFramerate).
+[`targetFramerate`](/{{{polymer_version_dir}}}/docs/api/elements/dom-repeat#DomRepeat-property-targetFramerate).
 
 You can also set a debounce time that must pass before a `filter` or `sort`
 function is re-run by setting the
-[`delay`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.DomRepeat#property-delay)
+[`delay`](/{{{polymer_version_dir}}}/docs/api/elements/dom-repeat#DomRepeat-property-delay)
 property.
 
 ## Data bind an array selection (array-selector) {#array-selector}

app/3.0/docs/upgrade.md

@@ -1395,7 +1395,7 @@ rather than being bundled in with `Polymer.Element`. For details, see
 
 In many cases you can use the native platform features (such as `setTimeout` or
 `requestAnimationFrame` instead of the `async` call. Polymer 2.x also provides an optional
-[`Polymer.Async`](/{{{polymer_version_dir}}}/docs/api/namespaces/Polymer.Async) module that provides
+[`Polymer.Async`](/{{{polymer_version_dir}}}/docs/api/utils/async) module that provides
 a set of Async APIs with a common interface. This is particularly useful for microtask timing, which
 is harder to time consistently across browsers.
 
@@ -1546,7 +1546,7 @@ separate, optional imports. These include:
 -   [`<dom-bind>` element](devguide/templates#dom-bind)
 -   [`<dom-if>` element](devguide/templates#dom-if)
 -   [`<dom-repeat>` element](devguide/templates#dom-repeat)
--   [`Polymer.RenderStatus`](/{{{polymer_version_dir}}}/docs/api/namespaces/Polymer.RenderStatus)
+-   [`Polymer.RenderStatus`](/{{{polymer_version_dir}}}/docs/api/utils/render-status)
     module.
 
 Element imports are found in the Polymer folder under `/lib/elements`, mixins under `/lib/mixins`,

app/3.0/toolbox/case-study.md

@@ -129,7 +129,7 @@ _pageChanged(page, oldPage) {
 In the logic above, the home view is built into the app shell, but the other
 views are demand-loaded fragments.
 
-Shop also uses [`dom-if`](/{{{polymer_version_dir}}}/docs/api/elements/Polymer.DomIf) templates to lazily create views:
+Shop also uses [`dom-if`](/{{{polymer_version_dir}}}/docs/api/elements/dom-if) templates to lazily create views:
 
 ```html
 <!-- Lazy-create the tabs for larger screen sizes. -->