@types/ember

  • Version 4.0.0
  • Published
  • 24.1 kB
  • 18 dependencies
  • MIT license

Install

npm i @types/ember
yarn add @types/ember
pnpm add @types/ember

Overview

TypeScript definitions for Ember.js

Index

Namespaces

Namespaces

namespace Ember

namespace Ember {}

    variable A

    const A: any;

      variable ActionHandler

      const ActionHandler: any;

        variable addListener

        const addListener: any;

          variable addObserver

          const addObserver: any;

            variable Array

            const Array: any;

              variable assert

              const assert: any;

                variable assign

                const assign: any;
                • Copy properties from a source object to a target object.

                  Deprecated

                  until v5.0. You should replace any calls to Ember.assign with Object.assign or use the object spread operator.

                variable cacheFor

                const cacheFor: any;

                  variable Comparable

                  const Comparable: EmberMixin<Comparable>;

                    variable compare

                    const compare: any;

                      variable computed

                      const computed: any;

                        variable debug

                        const debug: any;

                          variable Debug

                          const Debug: { registerDeprecationHandler: any; registerWarnHandler: any };

                            variable defineProperty

                            const defineProperty: any;

                              variable deprecate

                              const deprecate: any;

                                variable deprecateFunc

                                const deprecateFunc: any;

                                  variable Enumerable

                                  const Enumerable: any;

                                    variable Error

                                    const Error: any;
                                    • A subclass of the JavaScript Error object for use in Ember.

                                    variable Evented

                                    const Evented: any;

                                      variable expandProperties

                                      const expandProperties: any;

                                        variable get

                                        const get: any;

                                          variable getOwner

                                          const getOwner: any;

                                            variable getProperties

                                            const getProperties: any;

                                              variable guidFor

                                              const guidFor: any;

                                                variable htmlSafe

                                                const htmlSafe: any;

                                                  variable isArray

                                                  const isArray: any;

                                                    variable isBlank

                                                    const isBlank: any;

                                                      variable isEmpty

                                                      const isEmpty: any;

                                                        variable isEqual

                                                        const isEqual: any;
                                                        • Creates a shallow copy of the passed object. A deep copy of the object is returned if the optional deep argument is true.

                                                        variable isHTMLSafe

                                                        const isHTMLSafe: any;

                                                          variable isNone

                                                          const isNone: any;

                                                            variable isPresent

                                                            const isPresent: any;

                                                              variable MutableArray

                                                              const MutableArray: any;

                                                                variable MutableEnumerable

                                                                const MutableEnumerable: any;

                                                                  variable NativeArray

                                                                  const NativeArray: any;

                                                                    variable notifyPropertyChange

                                                                    const notifyPropertyChange: any;

                                                                      variable Observable

                                                                      const Observable: any;

                                                                        variable observer

                                                                        const observer: any;

                                                                          variable on

                                                                          const on: any;

                                                                            variable onerror

                                                                            let onerror: (error: Error) => void;
                                                                            • A function may be assigned to Ember.onerror to be called when Ember internals encounter an error. This is useful for specialized error handling and reporting code.

                                                                            variable platform

                                                                            const platform: { defineProperty: boolean; hasPropertyAccessors: boolean };

                                                                              variable PromiseProxyMixin

                                                                              const PromiseProxyMixin: any;

                                                                                variable removeListener

                                                                                const removeListener: any;

                                                                                  variable removeObserver

                                                                                  const removeObserver: any;

                                                                                    variable RSVP

                                                                                    const RSVP: any;

                                                                                      variable run

                                                                                      const run: Run;

                                                                                        variable runInDebug

                                                                                        const runInDebug: any;

                                                                                          variable sendEvent

                                                                                          const sendEvent: any;

                                                                                            variable set

                                                                                            const set: any;

                                                                                              variable setOwner

                                                                                              const setOwner: any;

                                                                                                variable setProperties

                                                                                                const setProperties: any;

                                                                                                  variable testing

                                                                                                  const testing: boolean;
                                                                                                  • This property indicates whether or not this application is currently in testing mode. This is set when setupForTesting is called on the current application.

                                                                                                  variable trySet

                                                                                                  const trySet: any;

                                                                                                    variable typeOf

                                                                                                    const typeOf: any;

                                                                                                      variable VERSION

                                                                                                      const VERSION: string;
                                                                                                      • The semantic version

                                                                                                      variable ViewTargetActionSupport

                                                                                                      const ViewTargetActionSupport: Mixin<ViewTargetActionSupport, EmberObjectNs.default>;

                                                                                                        variable ViewUtils

                                                                                                        const ViewUtils: { isSimpleClick(event: Event): boolean };

                                                                                                          variable warn

                                                                                                          const warn: any;

                                                                                                            function getEngineParent

                                                                                                            getEngineParent: (engine: EngineInstance) => EngineInstance;
                                                                                                            • getEngineParent retrieves an engine instance's parent instance.

                                                                                                            class Application

                                                                                                            class Application extends EmberApplicationNs.default {}

                                                                                                              class ApplicationInstance

                                                                                                              class ApplicationInstance extends EmberApplicationInstanceNs.default {}

                                                                                                                class ArrayProxy

                                                                                                                class ArrayProxy<T> extends EmberArrayProxy<T> {}

                                                                                                                  class Component

                                                                                                                  class Component extends EmberComponent {}

                                                                                                                    class ComputedProperty

                                                                                                                    class ComputedProperty<Get, Set = Get> extends EmberObjectComputedNs.default<
                                                                                                                    Get,
                                                                                                                    Set
                                                                                                                    > {}

                                                                                                                      class Container

                                                                                                                      class Container {}
                                                                                                                      • A container used to instantiate and cache objects.

                                                                                                                      method factoryFor

                                                                                                                      factoryFor: (fullName: string, options?: {}) => unknown;
                                                                                                                      • Given a fullName, return the corresponding factory. The consumer of the factory is responsible for the destruction of any factory instances, as there is no way for the container to ensure instances are destroyed when it itself is destroyed.

                                                                                                                      class ContainerDebugAdapter

                                                                                                                      class ContainerDebugAdapter extends _ContainerDebugAdapter {}

                                                                                                                        class Controller

                                                                                                                        class Controller extends EmberControllerNs.default {}

                                                                                                                          class CoreObject

                                                                                                                          class CoreObject extends EmberCoreObject {}

                                                                                                                            class DataAdapter

                                                                                                                            class DataAdapter extends EmberDataAdapter {}

                                                                                                                              class Engine

                                                                                                                              class Engine extends EmberEngineNs.default {}

                                                                                                                                class EngineInstance

                                                                                                                                class EngineInstance extends EmberEngineInstanceNs.default {}

                                                                                                                                  class EventDispatcher

                                                                                                                                  class EventDispatcher extends EmberEventDispatcher {}

                                                                                                                                    class HashLocation

                                                                                                                                    class HashLocation extends EmberRoutingHashLocation {}

                                                                                                                                      class Helper

                                                                                                                                      class Helper extends EmberHelper {}

                                                                                                                                        class HistoryLocation

                                                                                                                                        class HistoryLocation extends EmberRoutingHistoryLocation {}

                                                                                                                                          class Mixin

                                                                                                                                          class Mixin<T, Base = EmberObjectNs.default> extends EmberMixin<T, Base> {}

                                                                                                                                            class Namespace

                                                                                                                                            class Namespace extends Object {}
                                                                                                                                            • A Namespace is an object usually used to contain other objects or methods such as an application or framework. Create a namespace anytime you want to define one of these new containers.

                                                                                                                                            class NoneLocation

                                                                                                                                            class NoneLocation extends EmberRoutingNoneLocation {}

                                                                                                                                              class Object

                                                                                                                                              class Object extends EmberObjectNs.default {}

                                                                                                                                                class ObjectProxy

                                                                                                                                                class ObjectProxy extends EmberObjectProxyNs.default {}

                                                                                                                                                  class Registry

                                                                                                                                                  class Registry extends EmberRegistry {}

                                                                                                                                                    class Route

                                                                                                                                                    class Route extends EmberRoutingRoute {}

                                                                                                                                                      class Router

                                                                                                                                                      class Router extends EmberRoutingRouter {}

                                                                                                                                                        class Service

                                                                                                                                                        class Service extends Object {}

                                                                                                                                                          interface ArrayPrototypeExtensions

                                                                                                                                                          interface ArrayPrototypeExtensions<T> extends EmberArrayProtoExtensions<T> {}

                                                                                                                                                            interface Comparable

                                                                                                                                                            interface Comparable {}
                                                                                                                                                            • Implements some standard methods for comparing objects. Add this mixin to any class you create that can compare its instances.

                                                                                                                                                            method compare

                                                                                                                                                            compare: (a: unknown, b: unknown) => number;

                                                                                                                                                              interface Run

                                                                                                                                                              interface Run extends RunFn, EmberRunloop {}

                                                                                                                                                                interface ViewTargetActionSupport

                                                                                                                                                                interface ViewTargetActionSupport {}

                                                                                                                                                                  property actionContext

                                                                                                                                                                  actionContext: unknown;

                                                                                                                                                                    property target

                                                                                                                                                                    target: unknown;

                                                                                                                                                                      type Array

                                                                                                                                                                      type Array<T> = EmberArray<T>;

                                                                                                                                                                        type EmberRunloop

                                                                                                                                                                        type EmberRunloop = typeof EmberRunloopNs;

                                                                                                                                                                          type Enumerable

                                                                                                                                                                          type Enumerable<T> = EmberEnumerable<T>;

                                                                                                                                                                            type MutableArray

                                                                                                                                                                            type MutableArray<T> = EmberMutableArray<T>;

                                                                                                                                                                              type MutableEnumerable

                                                                                                                                                                              type MutableEnumerable<T> = EmberMutableEnumerable<T>;

                                                                                                                                                                                type NativeArray

                                                                                                                                                                                type NativeArray<T> = EmberNativeArray<T>;

                                                                                                                                                                                  type RunFn

                                                                                                                                                                                  type RunFn = EmberRunloop['run'];

                                                                                                                                                                                    namespace Ember.ENV

                                                                                                                                                                                    namespace Ember.ENV {}

                                                                                                                                                                                      variable EXTEND_PROTOTYPES

                                                                                                                                                                                      const EXTEND_PROTOTYPES: { Array: boolean; Function: boolean; String: boolean };

                                                                                                                                                                                        variable LOG_BINDINGS

                                                                                                                                                                                        const LOG_BINDINGS: boolean;

                                                                                                                                                                                          variable LOG_STACKTRACE_ON_DEPRECATION

                                                                                                                                                                                          const LOG_STACKTRACE_ON_DEPRECATION: boolean;

                                                                                                                                                                                            variable LOG_VERSION

                                                                                                                                                                                            const LOG_VERSION: boolean;

                                                                                                                                                                                              variable MODEL_FACTORY_INJECTIONS

                                                                                                                                                                                              const MODEL_FACTORY_INJECTIONS: boolean;

                                                                                                                                                                                                variable RAISE_ON_DEPRECATION

                                                                                                                                                                                                const RAISE_ON_DEPRECATION: boolean;

                                                                                                                                                                                                  namespace Ember.Handlebars

                                                                                                                                                                                                  namespace Ember.Handlebars {}

                                                                                                                                                                                                    function compile

                                                                                                                                                                                                    compile: {
                                                                                                                                                                                                    (string: string): (...args: any[]) => any;
                                                                                                                                                                                                    (environment: any, options?: any, context?: any, asObject?: any): any;
                                                                                                                                                                                                    };

                                                                                                                                                                                                      function createFrame

                                                                                                                                                                                                      createFrame: (objec: any) => any;

                                                                                                                                                                                                        function Exception

                                                                                                                                                                                                        Exception: (message: string) => void;

                                                                                                                                                                                                          function log

                                                                                                                                                                                                          log: (level: string, str: string) => void;

                                                                                                                                                                                                            function parse

                                                                                                                                                                                                            parse: (string: string) => any;

                                                                                                                                                                                                              function precompile

                                                                                                                                                                                                              precompile: (string: string, options: any) => void;

                                                                                                                                                                                                                function print

                                                                                                                                                                                                                print: (ast: any) => void;

                                                                                                                                                                                                                  function registerHelper

                                                                                                                                                                                                                  registerHelper: (name: string, helper: any) => void;

                                                                                                                                                                                                                    function registerPartial

                                                                                                                                                                                                                    registerPartial: (name: string, str: any) => void;

                                                                                                                                                                                                                      class Compiler

                                                                                                                                                                                                                      class Compiler {}

                                                                                                                                                                                                                        class JavaScriptCompiler

                                                                                                                                                                                                                        class JavaScriptCompiler {}

                                                                                                                                                                                                                          class SafeString

                                                                                                                                                                                                                          class SafeString extends EmberTemplateHandlebarsNs.SafeString {}

                                                                                                                                                                                                                            namespace Ember.inject

                                                                                                                                                                                                                            namespace Ember.inject {}
                                                                                                                                                                                                                            • Namespace for injection helper methods.

                                                                                                                                                                                                                            variable service

                                                                                                                                                                                                                            const service: any;

                                                                                                                                                                                                                              function controller

                                                                                                                                                                                                                              controller: {
                                                                                                                                                                                                                              (): ComputedProperty<Controller>;
                                                                                                                                                                                                                              <K extends string | number | symbol>(name: K): ComputedProperty<
                                                                                                                                                                                                                              ControllerRegistry,
                                                                                                                                                                                                                              ControllerRegistry
                                                                                                                                                                                                                              >;
                                                                                                                                                                                                                              };
                                                                                                                                                                                                                              • Creates a property that lazily looks up another controller in the container. Can only be used when defining another controller.

                                                                                                                                                                                                                              namespace Ember.RSVP

                                                                                                                                                                                                                              namespace Ember.RSVP {}

                                                                                                                                                                                                                                type Promise

                                                                                                                                                                                                                                type Promise<T> = Rsvp.Promise<T>;

                                                                                                                                                                                                                                  namespace Ember.String

                                                                                                                                                                                                                                  namespace Ember.String {}

                                                                                                                                                                                                                                    variable camelize

                                                                                                                                                                                                                                    const camelize: any;

                                                                                                                                                                                                                                      variable capitalize

                                                                                                                                                                                                                                      const capitalize: any;

                                                                                                                                                                                                                                        variable classify

                                                                                                                                                                                                                                        const classify: any;

                                                                                                                                                                                                                                          variable dasherize

                                                                                                                                                                                                                                          const dasherize: any;

                                                                                                                                                                                                                                            variable decamelize

                                                                                                                                                                                                                                            const decamelize: any;

                                                                                                                                                                                                                                              variable htmlSafe

                                                                                                                                                                                                                                              const htmlSafe: any;

                                                                                                                                                                                                                                                variable isHTMLSafe

                                                                                                                                                                                                                                                const isHTMLSafe: any;

                                                                                                                                                                                                                                                  variable underscore

                                                                                                                                                                                                                                                  const underscore: any;

                                                                                                                                                                                                                                                    variable w

                                                                                                                                                                                                                                                    const w: any;

                                                                                                                                                                                                                                                      function fmt

                                                                                                                                                                                                                                                      fmt: (...args: string[]) => string;

                                                                                                                                                                                                                                                        namespace Ember.Template

                                                                                                                                                                                                                                                        namespace Ember.Template {}

                                                                                                                                                                                                                                                          variable htmlSafe

                                                                                                                                                                                                                                                          const htmlSafe: any;

                                                                                                                                                                                                                                                            variable isHTMLSafe

                                                                                                                                                                                                                                                            const isHTMLSafe: any;

                                                                                                                                                                                                                                                              namespace Ember.Test

                                                                                                                                                                                                                                                              namespace Ember.Test {}
                                                                                                                                                                                                                                                              • This is a container for an assortment of testing related functionality

                                                                                                                                                                                                                                                              variable adapter

                                                                                                                                                                                                                                                              const adapter: EmberTestAdapter;
                                                                                                                                                                                                                                                              • Used to allow ember-testing to communicate with a specific testing framework.

                                                                                                                                                                                                                                                              variable registerAsyncHelper

                                                                                                                                                                                                                                                              const registerAsyncHelper: any;

                                                                                                                                                                                                                                                                variable registerHelper

                                                                                                                                                                                                                                                                const registerHelper: any;

                                                                                                                                                                                                                                                                  variable registerWaiter

                                                                                                                                                                                                                                                                  const registerWaiter: any;

                                                                                                                                                                                                                                                                    variable unregisterHelper

                                                                                                                                                                                                                                                                    const unregisterHelper: any;

                                                                                                                                                                                                                                                                      variable unregisterWaiter

                                                                                                                                                                                                                                                                      const unregisterWaiter: any;

                                                                                                                                                                                                                                                                        function checkWaiters

                                                                                                                                                                                                                                                                        checkWaiters: () => boolean;
                                                                                                                                                                                                                                                                        • Iterates through each registered test waiter, and invokes its callback. If any waiter returns false, this method will return true indicating that the waiters have not settled yet.

                                                                                                                                                                                                                                                                        function onInjectHelpers

                                                                                                                                                                                                                                                                        onInjectHelpers: (callback: (app: Application) => void) => void;
                                                                                                                                                                                                                                                                        • Used to register callbacks to be fired whenever App.injectTestHelpers is called.

                                                                                                                                                                                                                                                                        function promise

                                                                                                                                                                                                                                                                        promise: <T>(
                                                                                                                                                                                                                                                                        resolver: (
                                                                                                                                                                                                                                                                        resolve: (value?: T | PromiseLike<T>) => void,
                                                                                                                                                                                                                                                                        reject: (reason?: unknown) => void
                                                                                                                                                                                                                                                                        ) => void,
                                                                                                                                                                                                                                                                        label?: string
                                                                                                                                                                                                                                                                        ) => Promise<T>;
                                                                                                                                                                                                                                                                        • This returns a thenable tailored for testing. It catches failed onSuccess callbacks and invokes the Ember.Test.adapter.exception callback in the last chained then.

                                                                                                                                                                                                                                                                        function resolve

                                                                                                                                                                                                                                                                        resolve: <T>(value?: T | PromiseLike<T>, label?: string) => Promise<T>;
                                                                                                                                                                                                                                                                        • Replacement for Ember.RSVP.resolve The only difference is this uses an instance of Ember.Test.Promise

                                                                                                                                                                                                                                                                        class Adapter

                                                                                                                                                                                                                                                                        class Adapter extends EmberTestAdapter {}

                                                                                                                                                                                                                                                                          class Promise

                                                                                                                                                                                                                                                                          class Promise<T> extends Rsvp.Promise<T> {}

                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                            executor: (
                                                                                                                                                                                                                                                                            resolve: (value?: T | PromiseLike<T>) => void,
                                                                                                                                                                                                                                                                            reject: (reason?: unknown) => void
                                                                                                                                                                                                                                                                            ) => void
                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                              class QUnitAdapter

                                                                                                                                                                                                                                                                              class QUnitAdapter extends EmberTestAdapter {}
                                                                                                                                                                                                                                                                              • This class implements the methods defined by Ember.Test.Adapter for the QUnit testing framework.

                                                                                                                                                                                                                                                                              Package Files (1)

                                                                                                                                                                                                                                                                              Dependencies (18)

                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                              You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/ember.

                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/@types/ember)
                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/@types/ember"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>