TypeScript interfaces.Handle類代碼示例

		'append/remove': function () {
			const dfd = this.async(250);

			let handle: Handle;
			let h1: HTMLElement;

			const callback = function(changes: WatcherRecord[]) {
				changes = changes.filter(value => value.node.nodeType === 1);
				assert.strictEqual(changes.length, 2, 'there should be 2 changes');
				assert.strictEqual(changes[0].type, ChangeType.Added, 'change type should be Added');
				assert.strictEqual(changes[1].type, ChangeType.Removed, 'change type should be Removed');
				assert.strictEqual(changes[0].node, h1);
				handle.destroy();
				dfd.resolve();
			};

			doc.body.innerHTML = '<div></div>';
			h1 = doc.createElement('h1');

			handle = watch(doc.body, callback);
			while (doc.body.lastChild) {
				doc.body.removeChild(doc.body.lastChild);
			}
			doc.body.appendChild(h1);
		},

    'basic': function () {
        const dfd = this.async(250);

        let handle: Handle;
        let div: HTMLDivElement;

        const callback = function (changes: WatcherRecord[]) {
            /* jsdom doesn't create text nodes, but other browsers do, but lets just focus on the nodes we care about */
            changes = changes.filter(function (value: WatcherRecord) {
                return value.node.nodeType === 1;
            });
            assert.equal(changes.length, 3);
            assert.equal(changes[0].type, WatchType.Added);
            assert.equal(changes[1].type, WatchType.Added);
            assert.equal(changes[2].type, WatchType.Added);
            assert.equal(changes[2].node, div);
            handle.destroy();
            doc.body.innerHTML = '';
            dfd.resolve();
        };

        handle = watch(doc.body, callback);
        doc.body.innerHTML = '<div></div><div></div>';
        div = doc.createElement('div');
        doc.body.appendChild(div);
    }

		}).then(() => action);
		const registryHandle = actions.get(app).register(id, () => promise);

		return {
			destroy() {
				this.destroy = noop;
				instanceHandle.destroy();
				registryHandle.destroy();
			}
		};
	},

	registerActionFactory(id: Identifier, factory: ActionFactory): Handle {
		const app: App = this;
		let destroyed = false;
		let instanceHandle: Handle;
		let registryHandle = actions.get(app).register(id, () => {
			const promise = Promise.resolve()
				.then(() => {
					// Always call the factory in a future turn. This harmonizes behavior regardless of whether the
					// factory is registered through this method or loaded from a definition.
					return factory(app._registry);
				})
				.then((action) => {
					if (!destroyed) {
						instanceHandle = app._instanceRegistry.addAction(action, id);
					}

					// Configure the action, allow for a promise to be returned.
					return Promise.resolve(action.configure(app._registry)).then(() => {
						return action;

			setTimeout(function () {
				handle.destroy();
				doc.body.appendChild(doc.createElement('div'));
			}, 200);