EmberJS API Manual
Class
Method
Property
Event
Namespace
Module
Guide
- Managing Dependencies
- Addons - Managing Dependencies
- Bower - Managing Dependencies
- Other assets - Managing Dependencies
- Compiling Assets - Managing Dependencies
- Globals provided by Javascript assets - Managing Dependencies
- AMD Javascript modules - Managing Dependencies
- Environment Specific Assets - Managing Dependencies
- CSS - Managing Dependencies
- Other Assets - Managing Dependencies
- Applications and Instances
- Dependency Injection
- Factory Registrations - Dependency Injection
- Registering Already Instantiated Objects - Dependency Injection
- Registering Singletons vs. Non-Singletons - Dependency Injection
- Factory Injections - Dependency Injection
- Ad Hoc Injections - Dependency Injection
- Factory Instance Lookups - Dependency Injection
- Using an Application Instance Within an Instance Initializer - Dependency Injection
- Getting an Application Instance from a Factory Instance - Dependency Injection
- Initializers
- Application Initializers - Initializers
- Application Instance Initializers - Initializers
- Specifying Initializer Order - Initializers
- The Run Loop
- Why is the run loop useful? - The Run Loop
- How does the Run Loop work in Ember? - The Run Loop
- What happens in these queues? - The Run Loop
- In what order are jobs executed on the queues? - The Run Loop
- An example of the internals - The Run Loop
- How do I tell Ember to start a run loop? - The Run Loop
- What happens if I forget to start a run loop in an async handler? - The Run Loop
- How is runloop behaviour different when testing? - The Run Loop
- Where can I find more information? - The Run Loop
- Services
- Defining Services - Services
- Accessing Services - Services
- Using Block Params
- Return values from a component with yield - Using Block Params
- Consuming yielded values with block params - Using Block Params
- Supporting both block and non-block component usage in one template - Using Block Params
- Customizing a Component's Element
- Customizing the Element - Customizing a Component's Element
- Customizing Class Names - Customizing a Component's Element
- Customizing Attributes - Customizing a Component's Element
- Defining a Component
- Defining a Component Subclass - Defining a Component
- Dynamically rendering a component - Defining a Component
- Handling Events
- Sending Actions - Handling Events
- Event Names - Handling Events
- Passing Properties to a Component
- Positional Params - Passing Properties to a Component
- The Component Lifecycle
- Order of Lifecycle Hooks Called - The Component Lifecycle
- On Initial Render - The Component Lifecycle
- On Re-Render - The Component Lifecycle
- On Component Destroy - The Component Lifecycle
- Lifecycle Hook Examples - The Component Lifecycle
- Resetting Presentation State on Attribute Change with didUpdateAttrs - The Component Lifecycle
- Formatting Component Attributes with didReceiveAttrs - The Component Lifecycle
- Integrating with Third-Party Libraries with didInsertElement - The Component Lifecycle
- Making Updates to the Rendered DOM with didRender - The Component Lifecycle
- Detaching and Tearing Down Component Elements with willDestroyElement - The Component Lifecycle
- Triggering Changes with Actions
- Creating the Component - Triggering Changes with Actions
- Designing the Action - Triggering Changes with Actions
- Implementing the Action - Triggering Changes with Actions
- Designing the Child Component - Triggering Changes with Actions
- Passing the Action to the Component - Triggering Changes with Actions
- Handling Action Completion - Triggering Changes with Actions
- Passing Arguments - Triggering Changes with Actions
- Invoking Actions Directly on Component Collaborators - Triggering Changes with Actions
- Destructuring Objects Passed as Action Arguments - Triggering Changes with Actions
- Calling Actions Up Multiple Component Layers - Triggering Changes with Actions
- Wrapping Content in a Component
- Sharing Component Data with its Wrapped Content - Wrapping Content in a Component
- Configuring Ember CLI
- Configuring Your App
- Debugging
- Routing - Debugging
- Views / Templates - Debugging
- Controllers - Debugging
- Observers / Binding - Debugging
- Miscellaneous - Debugging
- Disabling Prototype Extensions
- Life Without Prototype Extension - Disabling Prototype Extensions
- Arrays - Disabling Prototype Extensions
- Strings - Disabling Prototype Extensions
- Functions - Disabling Prototype Extensions
- Embedding Applications
- Changing the Root Element - Embedding Applications
- Disabling URL Management - Embedding Applications
- Specifying a Root URL - Embedding Applications
- Feature Flags
- Feature Life-Cycle - Feature Flags
- Flagging Details - Feature Flags
- Feature Listing (FEATURES.md) - Feature Flags
- Enabling At Runtime - Feature Flags
- Handling Deprecations
- Filtering Deprecations - Handling Deprecations
- Deprecation Workflow - Handling Deprecations
- 1. Gather deprecations into one source - Handling Deprecations
- "2. ""Turn on"" a deprecation - Handling Deprecations"
- 3. Fix and Repeat - Handling Deprecations
- Silencing Deprecation Warnings During Compile - Handling Deprecations
- Deprecation Handling in Ember Inspector - Handling Deprecations
- Specifying the URL Type
- history - Specifying the URL Type
- hash - Specifying the URL Type
- none - Specifying the URL Type
- Adding New Features
- Bug Fixes - Adding New Features
- Features - Adding New Features
- Builds - Adding New Features
- features.json - Adding New Features
- Travis Testing - Adding New Features
- Go/No-Go Process - Adding New Features
- Beta Releases - Adding New Features
- Repositories
- Main Repositories - Repositories
- Libraries Used By Ember - Repositories
- Backburner - Repositories
- DAG Map - Repositories
- Glimmer 2 - Repositories
- HTMLBars - Repositories
- morph-range - Repositories
- Route Recognizer - Repositories
- router.js - Repositories
- RSVP - Repositories
- Managing Dependencies Between Controllers
- Controllers
- Inspecting Objects via the Container
- Inspecting Instances - Inspecting Objects via the Container
- Filter and Reload - Inspecting Objects via the Container
- Data Tab
- Inspecting Records - Data Tab
- Record States and Filtering - Data Tab
- Building a Data Custom Adapter - Data Tab
- Tackling Deprecations
- Ember CLI Deprecation Sources - Tackling Deprecations
- Transition Plans - Tackling Deprecations
- Filtering and Clearing - Tackling Deprecations
- Library Info
- Registering a Library - Library Info
- Installing the Inspector
- Google Chrome - Installing the Inspector
- Firefox - Installing the Inspector
- Via Bookmarklet - Installing the Inspector
- Mobile Devices - Installing the Inspector
- Object Inspector
- Viewing Objects - Object Inspector
- Exposing Objects to the Console - Object Inspector
- Editing Properties - Object Inspector
- Navigating the Inspector - Object Inspector
- Custom Property Grouping - Object Inspector
- Debugging Promises
- Promise States and Filtering - Debugging Promises
- Inspecting Settled Values - Debugging Promises
- Tracing - Debugging Promises
- Labeling Promises - Debugging Promises
- Rendering Performance
- Accuracy - Rendering Performance
- Toolbar - Rendering Performance
- Inspecting Routes
- Viewing the Current Route - Inspecting Routes
- Troubleshooting
- Ember Application Not Detected - Troubleshooting
- Using the Inspector with JS Bin - Troubleshooting
- Application is not Detected Without Reload - Troubleshooting
- Data Adapter Not Detected - Troubleshooting
- Promises Not Detected - Troubleshooting
- The View Tree
- Inspecting Templates - The View Tree
- Components and Inline Views - The View Tree
- Highlighting Templates - The View Tree
- Duration - The View Tree
- Core Concepts
- Router and Route Handlers - Core Concepts
- Templates - Core Concepts
- Models - Core Concepts
- Components - Core Concepts
- Installing Ember
- Dependencies - Installing Ember
- Node.js and npm - Installing Ember
- Git - Installing Ember
- Watchman (optional) - Installing Ember
- PhantomJS (optional) - Installing Ember
- Installation - Installing Ember
- Quick Start
- Install Ember - Quick Start
- Create a New Application - Quick Start
- Define a Route - Quick Start
- Create a UI Component - Quick Start
- Building For Production - Quick Start
- Web Development
- CDN - Web Development
- CoffeeScript, TypeScript - Web Development
- Evergreen browsers - Web Development
- ES3, ES5, ES5.1, ES6 (aka ES2015), etc - Web Development
- LESS, Sass - Web Development
- Linter, linting, jslint, jshint - Web Development
- Polyfill - Web Development
- Promise - Web Development
- SSR - Web Development
- Transpile - Web Development
- Shadow DOM - Web Development
- Virtual DOM - Web Development
- Creating, Updating and Deleting
- Creating Records - Creating, Updating and Deleting
- Updating Records - Creating, Updating and Deleting
- Persisting Records - Creating, Updating and Deleting
- Handling Validation Errors - Creating, Updating and Deleting
- Promises - Creating, Updating and Deleting
- Deleting Records - Creating, Updating and Deleting
- Customizing Adapters
- Customizing the JSONAPIAdapter - Customizing Adapters
- URL Conventions - Customizing Adapters
- Community Adapters - Customizing Adapters
- Customizing Serializers
- JSONAPISerializer Conventions - Customizing Serializers
- JSON API Document - Customizing Serializers
- Sideloaded Data - Customizing Serializers
- IDs - Customizing Serializers
- Attribute Names - Customizing Serializers
- Relationships - Customizing Serializers
- Creating Custom Transformations - Customizing Serializers
- JSONSerializer - Customizing Serializers
- EmbeddedRecordMixin - Customizing Serializers
- EmbeddedRecordsMixin Defaults - Customizing Serializers
- Authoring Serializers - Customizing Serializers
- Community Serializers - Customizing Serializers
- Defining Models
- Defining Attributes - Defining Models
- Transforms - Defining Models
- Options - Defining Models
- Finding Records
- Retrieving a Single Record - Finding Records
- Retrieving Multiple Records - Finding Records
- Querying for Multiple Records - Finding Records
- Querying for A Single Record - Finding Records
- Handling Metadata
- Models
- The Store and a Single Source of Truth - Models
- Convention Over Configuration with JSON API - Models
- Records - Models
- Adapter - Models
- Caching - Models
- Architecture Overview - Models
- Pushing Records into the Store
- Pushing Records - Pushing Records into the Store
- Relationships
- One-to-One - Relationships
- One-to-Many - Relationships
- Many-to-Many - Relationships
- Explicit Inverses - Relationships
- Reflexive Relations - Relationships
- Readonly Nested Data - Relationships
- Creating Records - Relationships
- Updating Existing Records - Relationships
- Removing Relationships - Relationships
- Relationships as Promises - Relationships
- Bindings
- One-Way Bindings - Bindings
- Classes and Instances
- Defining Classes - Classes and Instances
- Overriding Parent Class Methods - Classes and Instances
- Creating Instances - Classes and Instances
- Initializing Instances - Classes and Instances
- Accessing Object Properties - Classes and Instances
- Computed Properties
- What are Computed Properties? - Computed Properties
- Computed properties in action - Computed Properties
- Chaining computed properties - Computed Properties
- Dynamic updating - Computed Properties
- Setting Computed Properties - Computed Properties
- Computed property macros - Computed Properties
- Computed Properties and Aggregate Data
- Enumerables
- Use of Observable Methods and Properties - Enumerables
- API Overview - Enumerables
- Iterating Over an Enumerable - Enumerables
- First and Last Objects - Enumerables
- Map - Enumerables
- Filtering - Enumerables
- Aggregate Information (Every or Any) - Enumerables
- Objects in Ember
- Observers
- Observers and asynchrony - Observers
- Observers and object initialization - Observers
- Unconsumed Computed Properties Do Not Trigger Observers - Observers
- Outside of class definitions - Observers
- Reopening Classes and Instances
- Asynchronous Routing
- A Word on Promises... - Asynchronous Routing
- The Router Pauses for Promises - Asynchronous Routing
- When Promises Reject... - Asynchronous Routing
- Recovering from Rejection - Asynchronous Routing
- Defining Your Routes
- Basic Routes - Defining Your Routes
- Nested Routes - Defining Your Routes
- The application route - Defining Your Routes
- Index Routes - Defining Your Routes
- Dynamic Segments - Defining Your Routes
- Wildcard / globbing routes - Defining Your Routes
- Route Handlers - Defining Your Routes
- Routing
- Loading / Error Substates
- loading substates - Loading / Error Substates
- The loading event - Loading / Error Substates
- error substates - Loading / Error Substates
- The error event - Loading / Error Substates
- Preventing and Retrying Transitions
- Preventing Transitions via willTransition - Preventing and Retrying Transitions
- Aborting Transitions Within model, beforeModel, afterModel - Preventing and Retrying Transitions
- Storing and Retrying a Transition - Preventing and Retrying Transitions
- Query Parameters
- Specifying Query Parameters - Query Parameters
- link-to Helper - Query Parameters
- transitionTo - Query Parameters
- Opting into a full transition - Query Parameters
- Update URL with replaceState instead - Query Parameters
- Map a controller's property to a different query param key - Query Parameters
- Default values and deserialization - Query Parameters
- Sticky Query Param Values - Query Parameters
- Redirecting
- Transitioning Before the Model is Known - Redirecting
- Transitioning After the Model is Known - Redirecting
- Child Routes - Redirecting
- Rendering a Template
- Specifying a Route's Model
- Dynamic Models - Specifying a Route's Model
- Multiple Models - Specifying a Route's Model
- Actions
- Action Parameters - Actions
- Specifying the Type of Event - Actions
- Allowing Modifier Keys - Actions
- Allowing Default Browser Action - Actions
- Modifying the action's first parameter - Actions
- Attaching Actions to Non-Clickable Elements - Actions
- Binding Element Attributes
- Adding Data Attributes - Binding Element Attributes
- Conditionals
- Development Helpers
- Logging - Development Helpers
- Adding a breakpoint - Development Helpers
- Displaying a List of Items
- Accessing an item's index - Displaying a List of Items
- Empty Lists - Displaying a List of Items
- Displaying the Keys in an Object
- Re-rendering - Displaying the Keys in an Object
- Ordering - Displaying the Keys in an Object
- Empty Lists - Displaying the Keys in an Object
- Handlebars Basics
- Displaying Properties - Handlebars Basics
- Helpers - Handlebars Basics
- Input Helpers
- Text fields - Input Helpers
- Actions - Input Helpers
- Checkboxes - Input Helpers
- Text Areas - Input Helpers
- Binding dynamic attribute - Input Helpers
- Links
- The {{link-to}} Helper - Links
- Example for Multiple Segments - Links
- Setting query-params - Links
- Using link-to as an inline helper - Links
- Adding additional attributes on a link - Links
- Replacing history entries - Links
- Writing Helpers
- Helper Names - Writing Helpers
- Helper Arguments - Writing Helpers
- Named Arguments - Writing Helpers
- Class-based Helpers - Writing Helpers
- Escaping HTML Content - Writing Helpers
- Acceptance Tests
- Test Helpers - Acceptance Tests
- Asynchronous Helpers - Acceptance Tests
- Synchronous Helpers - Acceptance Tests
- Wait Helpers - Acceptance Tests
- Custom Test Helpers - Acceptance Tests
- Testing
- Acceptance Tests - Testing
- Unit Tests - Testing
- Integration Tests - Testing
- Testing Frameworks - Testing
- How to Run Your Tests - Testing
- Testing Components
- Testing User Interaction - Testing Components
- Testing Actions - Testing Components
- Stubbing Services - Testing Components
- Waiting on Asynchronous Behavior - Testing Components
- Testing Controllers
- Testing Controller Actions - Testing Controllers
- Testing Controller Needs - Testing Controllers
- Testing Models
- Testing Relationships - Testing Models
- Testing Routes
- Unit Testing Basics
- Testing Computed Properties - Unit Testing Basics
- Testing Object Methods - Unit Testing Basics
- Testing Observers - Unit Testing Basics
- An Autocomplete Component
- Deploying
- Deploying with scp - Deploying
- Deploying to surge.sh - Deploying
- Creating a new app
- Directory Structure - Creating a new app
- ES6 Modules - Creating a new app
- Upgrading Ember - Creating a new app
- The Development Server - Creating a new app
- Ember Data
- Using Mirage with Ember Data - Ember Data
- Updating the Model Hook - Ember Data
- Handlebars Helper
- The Model Hook
- Routes and Templates
- An About Route - Routes and Templates
- A Contact Route - Routes and Templates
- Navigating with Links and the {{link-to}} Helper - Routes and Templates
- An Index Route - Routes and Templates
- A Simple Component
- Hiding and Showing an Image - A Simple Component
Class(124)
Method(2256)
Property(547)
Event(77)
Namespace(11)
Module(14)
Guide(423)