TypeScript object.extend函數代碼示例

function testObserver() {
    EmberObject.extend({
        // TODO: enable after https://github.com/typed-ember/ember-cli-typescript/issues/290
        // valueObserver: observer('value', () => {
        //     // Executes whenever the "value" property changes
        // })
    });
}

function testOnce() {
    EmberObject.extend({
        init() {
            run.once(this, 'processFullName');
        },

        processFullName() {
        }
    });
}

test('didResize and debouncedDidResize hooks are on the object', (assert: Assert) => {

  const resizeAwareObject = EObj.extend(ResizeAwareMixin);
  const subject = resizeAwareObject.create();

  assert.ok(subject.didResize, 'didResize hook is present on the subject');
  assert.equal(typeof subject.didResize, 'function', 'didResize hook is a function');
  assert.ok(subject.debouncedDidResize, 'debouncedDidResize hook is present on the subject');
  assert.equal(typeof subject.debouncedDidResize, 'function', 'debouncedDidResize hook is a function');

});

function testOn() {
    const Job = EmberObject.extend({
        logCompleted: on('completed', () => {
            console.log('Job completed!');
        })
    });

    const job = Job.create();

    sendEvent(job, 'completed'); // Logs 'Job completed!'
}

function testBind() {
    EmberObject.extend({
        init() {
            const bound = run.bind(this, this.setupEditor);
            bound();
        },

        editor: null as string | null,

        setupEditor(editor: string) {
            this.set('editor', editor);
        }
    });
}

function testListener() {
    EmberObject.extend({
        init() {
            addListener(this, 'willDestroy', this, 'willDestroyListener');
            addListener(this, 'willDestroy', this, 'willDestroyListener', true);
            addListener(this, 'willDestroy', this, this.willDestroyListener);
            addListener(this, 'willDestroy', this, this.willDestroyListener, true);
            removeListener(this, 'willDestroy', this, 'willDestroyListener');
            removeListener(this, 'willDestroy', this, this.willDestroyListener);
        },
        willDestroyListener() {
        }
    });
}

function testSchedule() {
    EmberObject.extend({
        init() {
            run.schedule('sync', this, () => {
                // this will be executed in the first RunLoop queue, when bindings are synced
                console.log('scheduled on sync queue');
            });

            run.schedule('actions', this, () => {
                // this will be executed in the 'actions' queue, after bindings have synced.
                console.log('scheduled on actions queue');
            });
        }
    });

    run.schedule('actions', () => {
        // Do more things
    });
}

function testEvented() {
    const Person = EmberObject.extend(Evented, {
        greet() {
            this.trigger('greet');
        }
    });

    const person = Person.create();

    person.on('greet', () => {
        console.log('Our person has greeted');
    });

    person.on('greet', () => {
        console.log('Our person has greeted');
    }).one('greet', () => {
        console.log('Offer one-time special');
    }).off('event', {}, () => {});

    person.greet();
}

function testDebounce() {
    function runIt() {
    }

    const myContext = { name: 'debounce' };

    run.debounce(runIt, 150);
    run.debounce(myContext, runIt, 150);
    run.debounce(myContext, runIt, 150, true);

    EmberObject.extend({
        searchValue: 'test',
        fetchResults(value: string) {},

        actions: {
            handleTyping() {
                // the fetchResults function is passed into the component from its parent
                run.debounce(this, this.get('fetchResults'), this.get('searchValue'), 250);
            }
        }
    });
}

import { assertType } from './lib/assert';
import EmberObject from '@ember/object';

const ExtendClass = EmberObject.extend({
    foo: 'hello'
});

class ES6Class extends EmberObject {
    bar: string;
}

const TestClass = EmberObject;

if (ExtendClass.detect(TestClass)) {
    assertType<string>(TestClass.create().foo);
}

if (ES6Class.detect(TestClass)) {
    assertType<string>(TestClass.create().bar);
}