Interface Observable

An interface which adds "observable properties" and data binding functionality.

Can be easily implemented by a class by mixing the module:utils/observablemixin~Observable mixin.

class MyClass extends ObservableMixin( OtherBaseClass ) {
	// This class now implements the `Observable` interface.
}

Read more about the usage of this interface in the:

{@glink framework/architecture/core-editor-architecture#event-system-and-observables Event system and observables} section of the {@glink framework/architecture/core-editor-architecture Core editor architecture} guide,
{@glink framework/deep-dive/observables Observables deep-dive} guide.

interface Observable {
    bind<
        K extends
            | "set"
            | "bind"
            | "unbind"
            | "decorate"
            | "on"
            | "once"
            | "off"
            | "listenTo"
            | "stopListening"
            | "fire"
            | "delegate"
            | "stopDelegating",
    >(
        bindProperty: K,
    ): ObservableSingleBindChain<K, Observable[K]>;
    bind<
        K1 extends
            | "set"
            | "bind"
            | "unbind"
            | "decorate"
            | "on"
            | "once"
            | "off"
            | "listenTo"
            | "stopListening"
            | "fire"
            | "delegate"
            | "stopDelegating",
        K2 extends
            | "set"
            | "bind"
            | "unbind"
            | "decorate"
            | "on"
            | "once"
            | "off"
            | "listenTo"
            | "stopListening"
            | "fire"
            | "delegate"
            | "stopDelegating",
    >(
        bindProperty1: K1,
        bindProperty2: K2,
    ): ObservableDualBindChain<K1, Observable[K1], K2, Observable[K2]>;
    bind(
        ...bindProperties: (
            | "set"
            | "bind"
            | "unbind"
            | "decorate"
            | "on"
            | "once"
            | "off"
            | "listenTo"
            | "stopListening"
            | "fire"
            | "delegate"
            | "stopDelegating"
        )[],
    ): ObservableMultiBindChain;
    decorate(
        methodName:
            | "set"
            | "bind"
            | "unbind"
            | "decorate"
            | "on"
            | "once"
            | "off"
            | "listenTo"
            | "stopListening"
            | "fire"
            | "delegate"
            | "stopDelegating",
    ): void;
    delegate(...events: string[]): EmitterMixinDelegateChain;
    fire<TEvent extends BaseEvent>(
        eventOrInfo: GetNameOrEventInfo<TEvent>,
        ...args: TEvent["args"],
    ): GetEventInfo<TEvent>["return"];
    listenTo<TEvent extends BaseEvent>(
        emitter: Emitter,
        event: TEvent["name"],
        callback: GetCallback<TEvent>,
        options?: GetCallbackOptions<TEvent>,
    ): void;
    off(event: string, callback: Function): void;
    on<TEvent extends BaseEvent>(
        event: TEvent["name"],
        callback: GetCallback<TEvent>,
        options?: GetCallbackOptions<TEvent>,
    ): void;
    once<TEvent extends BaseEvent>(
        event: TEvent["name"],
        callback: GetCallback<TEvent>,
        options?: GetCallbackOptions<TEvent>,
    ): void;
    set<
        K extends
            | "set"
            | "bind"
            | "unbind"
            | "decorate"
            | "on"
            | "once"
            | "off"
            | "listenTo"
            | "stopListening"
            | "fire"
            | "delegate"
            | "stopDelegating",
    >(
        name: K,
        value: Observable[K],
    ): void;
    set(
        values: object & {
            bind?: unknown;
            decorate?: unknown;
            delegate?: unknown;
            fire?: unknown;
            listenTo?: unknown;
            off?: unknown;
            on?: unknown;
            once?: unknown;
            set?: unknown;
            stopDelegating?: unknown;
            stopListening?: unknown;
            unbind?: unknown;
        },
    ): void;
    stopDelegating(event?: string, emitter?: Emitter): void;
    stopListening(emitter?: Emitter, event?: string, callback?: Function): void;
    unbind(
        ...unbindProperties: (
            | "set"
            | "bind"
            | "unbind"
            | "decorate"
            | "on"
            | "once"
            | "off"
            | "listenTo"
            | "stopListening"
            | "fire"
            | "delegate"
            | "stopDelegating"
        )[],
    ): void;
}

Hierarchy (View Summary)

Emitter
- Observable

Index

Methods

bind decorate delegate fire listenTo off on once set stopDelegating stopListening unbind

Methods

bind

bind<
    K extends
        | "set"
        | "bind"
        | "unbind"
        | "decorate"
        | "on"
        | "once"
        | "off"
        | "listenTo"
        | "stopListening"
        | "fire"
        | "delegate"
        | "stopDelegating",
>(
    bindProperty: K,
): ObservableSingleBindChain<K, Observable[K]>
Binds #set observable properties to other objects implementing the module:utils/observablemixin~Observable interface.

Read more in the {@glink framework/deep-dive/observables#property-bindings dedicated} guide covering the topic of property bindings with some additional examples.

Consider two objects: a button and an associated command (both Observable).

A simple property binding could be as follows:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```
or even shorter:
```
button.bind( 'isEnabled' ).to( command );
```
which works in the following way:
- button.isEnabled instantly equals command.isEnabled,
- whenever command.isEnabled changes, button.isEnabled will immediately reflect its value.
Note: To release the binding, use module:utils/observablemixin~Observable#unbind.

You can also "rename" the property in the binding by specifying the new name in the to() chain:
```
button.bind( 'isEnabled' ).to( command, 'isWorking' );
```
It is possible to bind more than one property at a time to shorten the code:
```
button.bind( 'isEnabled', 'value' ).to( command );
```
which corresponds to:
```
button.bind( 'isEnabled' ).to( command );
button.bind( 'value' ).to( command );
```
The binding can include more than one observable, combining multiple data sources in a custom callback:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible',
	( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible );
```
Using a custom callback allows processing the value before passing it to the target property:
```
button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' );
```
It is also possible to bind to the same property in an array of observables. To bind a button to multiple commands (also Observables) so that each and every one of them must be enabled for the button to become enabled, use the following code:
```
button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled',
	( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled );
```
Type Parameters
- K extends
      | "set"
      | "bind"
      | "unbind"
      | "decorate"
      | "on"
      | "once"
      | "off"
      | "listenTo"
      | "stopListening"
      | "fire"
      | "delegate"
      | "stopDelegating"
Parameters
- bindProperty: K
  Observable property that will be bound to other observable(s).
Returns ObservableSingleBindChain<K, Observable[K]>
The bind chain with the to() and toMany() methods.

Label
SINGLE_BIND
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.d.ts:197
bind<
    K1 extends
        | "set"
        | "bind"
        | "unbind"
        | "decorate"
        | "on"
        | "once"
        | "off"
        | "listenTo"
        | "stopListening"
        | "fire"
        | "delegate"
        | "stopDelegating",
    K2 extends
        | "set"
        | "bind"
        | "unbind"
        | "decorate"
        | "on"
        | "once"
        | "off"
        | "listenTo"
        | "stopListening"
        | "fire"
        | "delegate"
        | "stopDelegating",
>(
    bindProperty1: K1,
    bindProperty2: K2,
): ObservableDualBindChain<K1, Observable[K1], K2, Observable[K2]>
Binds #set observable properties to other objects implementing the module:utils/observablemixin~Observable interface.

Read more in the {@glink framework/deep-dive/observables#property-bindings dedicated} guide covering the topic of property bindings with some additional examples.

Consider two objects: a button and an associated command (both Observable).

A simple property binding could be as follows:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```
or even shorter:
```
button.bind( 'isEnabled' ).to( command );
```
which works in the following way:
- button.isEnabled instantly equals command.isEnabled,
- whenever command.isEnabled changes, button.isEnabled will immediately reflect its value.
Note: To release the binding, use module:utils/observablemixin~Observable#unbind.

You can also "rename" the property in the binding by specifying the new name in the to() chain:
```
button.bind( 'isEnabled' ).to( command, 'isWorking' );
```
It is possible to bind more than one property at a time to shorten the code:
```
button.bind( 'isEnabled', 'value' ).to( command );
```
which corresponds to:
```
button.bind( 'isEnabled' ).to( command );
button.bind( 'value' ).to( command );
```
The binding can include more than one observable, combining multiple data sources in a custom callback:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible',
	( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible );
```
Using a custom callback allows processing the value before passing it to the target property:
```
button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' );
```
It is also possible to bind to the same property in an array of observables. To bind a button to multiple commands (also Observables) so that each and every one of them must be enabled for the button to become enabled, use the following code:
```
button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled',
	( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled );
```
Type Parameters
- K1 extends
      | "set"
      | "bind"
      | "unbind"
      | "decorate"
      | "on"
      | "once"
      | "off"
      | "listenTo"
      | "stopListening"
      | "fire"
      | "delegate"
      | "stopDelegating"
- K2 extends
      | "set"
      | "bind"
      | "unbind"
      | "decorate"
      | "on"
      | "once"
      | "off"
      | "listenTo"
      | "stopListening"
      | "fire"
      | "delegate"
      | "stopDelegating"
Parameters
- bindProperty1: K1
  Observable property that will be bound to other observable(s).
- bindProperty2: K2
  Observable property that will be bound to other observable(s).
Returns ObservableDualBindChain<K1, Observable[K1], K2, Observable[K2]>
The bind chain with the to() and toMany() methods.

Label
DUAL_BIND
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.d.ts:272
bind(
    ...bindProperties: (
        | "set"
        | "bind"
        | "unbind"
        | "decorate"
        | "on"
        | "once"
        | "off"
        | "listenTo"
        | "stopListening"
        | "fire"
        | "delegate"
        | "stopDelegating"
    )[],
): ObservableMultiBindChain
Binds #set observable properties to other objects implementing the module:utils/observablemixin~Observable interface.

Read more in the {@glink framework/deep-dive/observables#property-bindings dedicated} guide covering the topic of property bindings with some additional examples.

Consider two objects: a button and an associated command (both Observable).

A simple property binding could be as follows:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled' );
```
or even shorter:
```
button.bind( 'isEnabled' ).to( command );
```
which works in the following way:
- button.isEnabled instantly equals command.isEnabled,
- whenever command.isEnabled changes, button.isEnabled will immediately reflect its value.
Note: To release the binding, use module:utils/observablemixin~Observable#unbind.

You can also "rename" the property in the binding by specifying the new name in the to() chain:
```
button.bind( 'isEnabled' ).to( command, 'isWorking' );
```
It is possible to bind more than one property at a time to shorten the code:
```
button.bind( 'isEnabled', 'value' ).to( command );
```
which corresponds to:
```
button.bind( 'isEnabled' ).to( command );
button.bind( 'value' ).to( command );
```
The binding can include more than one observable, combining multiple data sources in a custom callback:
```
button.bind( 'isEnabled' ).to( command, 'isEnabled', ui, 'isVisible',
	( isCommandEnabled, isUIVisible ) => isCommandEnabled && isUIVisible );
```
Using a custom callback allows processing the value before passing it to the target property:
```
button.bind( 'isEnabled' ).to( command, 'value', value => value === 'heading1' );
```
It is also possible to bind to the same property in an array of observables. To bind a button to multiple commands (also Observables) so that each and every one of them must be enabled for the button to become enabled, use the following code:
```
button.bind( 'isEnabled' ).toMany( [ commandA, commandB, commandC ], 'isEnabled',
	( isAEnabled, isBEnabled, isCEnabled ) => isAEnabled && isBEnabled && isCEnabled );
```
Parameters
- ...bindProperties: (
      | "set"
      | "bind"
      | "unbind"
      | "decorate"
      | "on"
      | "once"
      | "off"
      | "listenTo"
      | "stopListening"
      | "fire"
      | "delegate"
      | "stopDelegating"
  )[]
  Observable properties that will be bound to other observable(s).
Returns ObservableMultiBindChain
The bind chain with the to() and toMany() methods.

Label
MANY_BIND
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.d.ts:346

decorate

decorate(
    methodName:
        | "set"
        | "bind"
        | "unbind"
        | "decorate"
        | "on"
        | "once"
        | "off"
        | "listenTo"
        | "stopListening"
        | "fire"
        | "delegate"
        | "stopDelegating",
): void
Turns the given methods of this object into event-based ones. This means that the new method will fire an event (named after the method) and the original action will be plugged as a listener to that event.

Read more in the {@glink framework/deep-dive/observables#decorating-object-methods dedicated} guide covering the topic of decorating methods with some additional examples.

Decorating the method does not change its behavior (it only adds an event), but it allows to modify it later on by listening to the method's event.

For example, to cancel the method execution the event can be module:utils/eventinfo~EventInfo#stop stopped:
```
class Foo extends ObservableMixin() {
	constructor() {
		super();
		this.decorate( 'method' );
	}

	method() {
		console.log( 'called!' );
	}
}

const foo = new Foo();
foo.on( 'method', ( evt ) => {
	evt.stop();
}, { priority: 'high' } );

foo.method(); // Nothing is logged.
```
Note: The high module:utils/priorities~PriorityString priority listener has been used to execute this particular callback before the one which calls the original method (which uses the "normal" priority).

It is also possible to change the returned value:
```
foo.on( 'method', ( evt ) => {
	evt.return = 'Foo!';
} );

foo.method(); // -> 'Foo'
```
Finally, it is possible to access and modify the arguments the method is called with:
```
method( a, b ) {
	console.log( `${ a }, ${ b }`  );
}

// ...

foo.on( 'method', ( evt, args ) => {
	args[ 0 ] = 3;

	console.log( args[ 1 ] ); // -> 2
}, { priority: 'high' } );

foo.method( 1, 2 ); // -> '3, 2'
```
Parameters
- methodName:
      | "set"
      | "bind"
      | "unbind"
      | "decorate"
      | "on"
      | "once"
      | "off"
      | "listenTo"
      | "stopListening"
      | "fire"
      | "delegate"
      | "stopDelegating"
  Name of the method to decorate.
Returns void
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.d.ts:429

delegate

delegate(...events: string[]): EmitterMixinDelegateChain
Delegates selected events to another module:utils/emittermixin~Emitter. For instance:
```
emitterA.delegate( 'eventX' ).to( emitterB );
emitterA.delegate( 'eventX', 'eventY' ).to( emitterC );
```
then eventX is delegated (fired by) emitterB and emitterC along with data:
```
emitterA.fire( 'eventX', data );
```
and eventY is delegated (fired by) emitterC along with data:
```
emitterA.fire( 'eventY', data );
```
Parameters
- ...events: string[]
  Event names that will be delegated to another emitter.
Returns EmitterMixinDelegateChain
Inherited from Emitter.delegate
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:184

fire

fire<TEvent extends BaseEvent>(
eventOrInfo: GetNameOrEventInfo<TEvent>,
...args: TEvent["args"],
): GetEventInfo<TEvent>["return"]
Fires an event, executing all callbacks registered for it.

The first parameter passed to callbacks is an module:utils/eventinfo~EventInfo object, followed by the optional args provided in the fire() method call.
Type Parameters
- TEvent extends BaseEvent
  The type describing the event. See module:utils/emittermixin~BaseEvent.
Parameters
- eventOrInfo: GetNameOrEventInfo<TEvent>
  The name of the event or EventInfo object if event is delegated.
- ...args: TEvent["args"]
  Additional arguments to be passed to the callbacks.
Returns GetEventInfo<TEvent>["return"]
By default the method returns undefined. However, the return value can be changed by listeners through modification of the module:utils/eventinfo~EventInfo#return evt.return's property (the event info is the first param of every callback).
Inherited from Emitter.fire
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:161

listenTo

listenTo<TEvent extends BaseEvent>(
    emitter: Emitter,
    event: TEvent["name"],
    callback: GetCallback<TEvent>,
    options?: GetCallbackOptions<TEvent>,
): void
Registers a callback function to be executed when an event is fired in a specific (emitter) object.

Events can be grouped in namespaces using :. When namespaced event is fired, it additionally fires all callbacks for that namespace.
```
// myEmitter.on( ... ) is a shorthand for myEmitter.listenTo( myEmitter, ... ).
myEmitter.on( 'myGroup', genericCallback );
myEmitter.on( 'myGroup:myEvent', specificCallback );

// genericCallback is fired.
myEmitter.fire( 'myGroup' );
// both genericCallback and specificCallback are fired.
myEmitter.fire( 'myGroup:myEvent' );
// genericCallback is fired even though there are no callbacks for "foo".
myEmitter.fire( 'myGroup:foo' );
```
An event callback can module:utils/eventinfo~EventInfo#stop stop the event and set the module:utils/eventinfo~EventInfo#return return value of the #fire method.
Type Parameters
- TEvent extends BaseEvent
  The type describing the event. See module:utils/emittermixin~BaseEvent.
Parameters
- emitter: Emitter
  The object that fires the event.
- event: TEvent["name"]
  The name of the event.
- callback: GetCallback<TEvent>
  The function to be called on event.
- Optionaloptions: GetCallbackOptions<TEvent>
  Additional options.
Returns void
Label
BASE_EMITTER
Inherited from Emitter.listenTo
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:131

off

off(event: string, callback: Function): void
Stops executing the callback on the given event. Shorthand for #stopListening this.stopListening( this, event, callback ).
Parameters
- event: string
  The name of the event.
- callback: Function
  The function to stop being called.
Returns void
Inherited from Emitter.off
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:101

on

on<TEvent extends BaseEvent>(
    event: TEvent["name"],
    callback: GetCallback<TEvent>,
    options?: GetCallbackOptions<TEvent>,
): void
Registers a callback function to be executed when an event is fired.

Shorthand for #listenTo this.listenTo( this, event, callback, options ) (it makes the emitter listen on itself).
Type Parameters
- TEvent extends BaseEvent
  The type descibing the event. See module:utils/emittermixin~BaseEvent.
Parameters
- event: TEvent["name"]
  The name of the event.
- callback: GetCallback<TEvent>
  The function to be called on event.
- Optionaloptions: GetCallbackOptions<TEvent>
  Additional options.
Returns void
Inherited from Emitter.on
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:83

once

once<TEvent extends BaseEvent>(
    event: TEvent["name"],
    callback: GetCallback<TEvent>,
    options?: GetCallbackOptions<TEvent>,
): void
Registers a callback function to be executed on the next time the event is fired only. This is similar to calling #on followed by #off in the callback.
Type Parameters
- TEvent extends BaseEvent
  The type descibing the event. See module:utils/emittermixin~BaseEvent.
Parameters
- event: TEvent["name"]
  The name of the event.
- callback: GetCallback<TEvent>
  The function to be called on event.
- Optionaloptions: GetCallbackOptions<TEvent>
  Additional options.
Returns void
Inherited from Emitter.once
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:93

set

set<
    K extends
        | "set"
        | "bind"
        | "unbind"
        | "decorate"
        | "on"
        | "once"
        | "off"
        | "listenTo"
        | "stopListening"
        | "fire"
        | "delegate"
        | "stopDelegating",
>(
    name: K,
    value: Observable[K],
): void
Creates and sets the value of an observable property of this object. Such a property becomes a part of the state and is observable.

This method throws the observable-set-cannot-override error if the observable instance already has a property with the given property name. This prevents from mistakenly overriding existing properties and methods, but means that foo.set( 'bar', 1 ) may be slightly slower than foo.bar = 1.

In TypeScript, those properties should be declared in class using declare keyword. In example:
```
public declare myProp: number;

constructor() {
	this.set( 'myProp', 2 );
}
```
Type Parameters
- K extends
      | "set"
      | "bind"
      | "unbind"
      | "decorate"
      | "on"
      | "once"
      | "off"
      | "listenTo"
      | "stopListening"
      | "fire"
      | "delegate"
      | "stopDelegating"
Parameters
- name: K
  The property's name.
- value: Observable[K]
  The property's value.
Returns void
Label
KEY_VALUE
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.d.ts:94
set(
    values: object & {
        bind?: unknown;
        decorate?: unknown;
        delegate?: unknown;
        fire?: unknown;
        listenTo?: unknown;
        off?: unknown;
        on?: unknown;
        once?: unknown;
        set?: unknown;
        stopDelegating?: unknown;
        stopListening?: unknown;
        unbind?: unknown;
    },
): void
Creates and sets the value of an observable properties of this object. Such a property becomes a part of the state and is observable.

It accepts a single object literal containing key/value pairs with properties to be set.

This method throws the observable-set-cannot-override error if the observable instance already has a property with the given property name. This prevents from mistakenly overriding existing properties and methods, but means that foo.set( 'bar', 1 ) may be slightly slower than foo.bar = 1.

In TypeScript, those properties should be declared in class using declare keyword. In example:
```
public declare myProp1: number;
public declare myProp2: string;

constructor() {
	this.set( {
		'myProp1: 2,
		'myProp2: 'foo'
	} );
}
```
Parameters
- values: object & {
      bind?: unknown;
      decorate?: unknown;
      delegate?: unknown;
      fire?: unknown;
      listenTo?: unknown;
      off?: unknown;
      on?: unknown;
      once?: unknown;
      set?: unknown;
      stopDelegating?: unknown;
      stopListening?: unknown;
      unbind?: unknown;
  }
  An object with name=>value pairs.
Returns void
Label
OBJECT
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.d.ts:121

stopDelegating

stopDelegating(event?: string, emitter?: Emitter): void
Stops delegating events. It can be used at different levels:
- To stop delegating all events.
- To stop delegating a specific event to all emitters.
- To stop delegating a specific event to a specific emitter.
Parameters
- Optionalevent: string
  The name of the event to stop delegating. If omitted, stops it all delegations.
- Optionalemitter: Emitter
  (requires event) The object to stop delegating a particular event to. If omitted, stops delegation of event to all emitters.
Returns void
Inherited from Emitter.stopDelegating
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:196

stopListening

stopListening(emitter?: Emitter, event?: string, callback?: Function): void
Stops listening for events. It can be used at different levels:
- To stop listening to a specific callback.
- To stop listening to a specific event.
- To stop listening to all events fired by a specific object.
- To stop listening to all events fired by all objects.
Parameters
- Optionalemitter: Emitter
  The object to stop listening to. If omitted, stops it for all objects.
- Optionalevent: string
  (Requires the emitter) The name of the event to stop listening to. If omitted, stops it for all events from emitter.
- Optionalcallback: Function
  (Requires the event) The function to be removed from the call list for the given event.
Returns void
Label
BASE_STOP
Inherited from Emitter.stopListening
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/emittermixin.d.ts:147

unbind

unbind(
    ...unbindProperties: (
        | "set"
        | "bind"
        | "unbind"
        | "decorate"
        | "on"
        | "once"
        | "off"
        | "listenTo"
        | "stopListening"
        | "fire"
        | "delegate"
        | "stopDelegating"
    )[],
): void
Removes the binding created with #bind.
```
// Removes the binding for the 'a' property.
A.unbind( 'a' );

// Removes bindings for all properties.
A.unbind();
```
Parameters
- ...unbindProperties: (
      | "set"
      | "bind"
      | "unbind"
      | "decorate"
      | "on"
      | "once"
      | "off"
      | "listenTo"
      | "stopListening"
      | "fire"
      | "delegate"
      | "stopDelegating"
  )[]
  Observable properties to be unbound. All the bindings will be released if no properties are provided.
Returns void
- Defined in node_modules/@ckeditor/ckeditor5-utils/src/observablemixin.d.ts:361

Interface Observable

Hierarchy (View Summary)

Index

Methods

Methods

bind

Type Parameters

Parameters

Returns ObservableSingleBindChain<K, Observable[K]>

Label

Type Parameters

Parameters

Returns ObservableDualBindChain<K1, Observable[K1], K2, Observable[K2]>

Label

Parameters

Returns ObservableMultiBindChain

Label

decorate

Parameters

Returns void

delegate

Parameters

Returns EmitterMixinDelegateChain

fire

Type Parameters

Parameters

Returns GetEventInfo<TEvent>["return"]

listenTo

Type Parameters

Parameters

Returns void

Label

off

Parameters

Returns void

on

Type Parameters

Parameters

Returns void

once

Type Parameters

Parameters

Returns void

set

Type Parameters

Parameters

Returns void

Label

Parameters

Returns void

Label

stopDelegating

Parameters

Returns void

stopListening

Parameters

Returns void

Label

unbind

Parameters

Returns void

Settings

On This Page