@types/ember

Version 4.0.11
Published 3 months ago
22.8 kB
17 dependencies
MIT license

Install

npm i @types/ember

yarn add @types/ember

pnpm add @types/ember

Overview

TypeScript definitions for ember

Index

Namespaces

Ember
Ember.ENV
Ember.Handlebars
Ember.inject
- controller()
- service
Ember.RSVP
- Promise
Ember.String
Ember.Template
- htmlSafe
- isHTMLSafe
Ember.Test

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 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)

index.d.ts

Dependencies (17)

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto 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>

Updated 3 months ago.
Package analyzed in 4129 ms.
Missing or incorrect documentation? Open an issue for this package.

@types/ember

Install

Overview

Index

Namespaces

Namespaces

namespace Ember

variable A

variable ActionHandler

variable addListener

variable addObserver

variable Array

variable assert

variable assign

Deprecated

variable cacheFor

variable Comparable

variable compare

variable computed

variable debug

variable Debug

variable defineProperty

variable deprecate

variable Enumerable

variable Error

variable Evented

variable expandProperties

variable get

variable getOwner

variable getProperties

variable guidFor

variable htmlSafe

variable isArray

variable isBlank

variable isEmpty

variable isEqual

variable isHTMLSafe

variable isNone

variable isPresent

variable MutableArray

variable MutableEnumerable

variable NativeArray

variable notifyPropertyChange

variable Observable

variable observer

variable on

variable onerror

variable platform

variable PromiseProxyMixin

variable removeListener

variable removeObserver

variable RSVP

variable run

variable runInDebug

variable sendEvent

variable set

variable setOwner

variable setProperties

variable testing

variable trySet

variable typeOf

variable VERSION

variable ViewTargetActionSupport

variable ViewUtils

variable warn

function getEngineParent

class Application

class ApplicationInstance

class ArrayProxy

class Component

class ComputedProperty

class Container

method factoryFor

class ContainerDebugAdapter

class Controller

class CoreObject

class DataAdapter

class Engine

class EngineInstance

class EventDispatcher