Remove global observer helper since it doesn't work with native classes

Author: wagenet

packages/@ember/-internals/glimmer/lib/helper.ts

@@ -136,6 +136,7 @@ export default class Helper<S = unknown> extends FrameworkObject {
     assert('expected compute to be defined', this.compute);
   }
 
+  // TODO: Update example to not use observer
   /**
     On a class-based helper, it may be useful to force a recomputation of that
     helpers value. This is akin to `rerender` on a component.

packages/@ember/-internals/glimmer/tests/integration/components/curly-components-test.js

@@ -6,7 +6,6 @@ import {
   equalTokens,
   equalsElement,
   runTask,
-  runLoopSettled,
 } from 'internal-test-helpers';
 
 import { tracked as trackedBuiltIn } from 'tracked-built-ins';
@@ -17,7 +16,7 @@ import { DEBUG } from '@glimmer/env';
 import { tracked } from '@ember/-internals/metal';
 import { alias } from '@ember/object/computed';
 import Service, { service } from '@ember/service';
-import EmberObject, { set, get, computed, observer } from '@ember/object';
+import EmberObject, { set, get, computed } from '@ember/object';
 
 import { Component, compile, htmlSafe } from '../../utils/helpers';
 import { backtrackingMessageFor } from '../../utils/debug-stack';
@@ -3096,44 +3095,6 @@ moduleFor(
       this.assertText('things');
     }
 
-    async ['@test didReceiveAttrs fires after .init() but before observers become active'](assert) {
-      let barCopyDidChangeCount = 0;
-
-      this.registerComponent('foo-bar', {
-        ComponentClass: Component.extend({
-          init() {
-            this._super(...arguments);
-            this.didInit = true;
-          },
-
-          didReceiveAttrs() {
-            assert.ok(this.didInit, 'expected init to have run before didReceiveAttrs');
-            this.set('barCopy', this.attrs.bar.value + 1);
-          },
-
-          barCopyDidChange: observer('barCopy', () => {
-            barCopyDidChangeCount++;
-          }),
-        }),
-
-        template: '{{this.bar}}-{{this.barCopy}}',
-      });
-
-      await this.render(`{{foo-bar bar=this.bar}}`, { bar: 3 });
-
-      this.assertText('3-4');
-
-      assert.strictEqual(barCopyDidChangeCount, 1, 'expected observer firing for: barCopy');
-
-      set(this.context, 'bar', 7);
-
-      await runLoopSettled();
-
-      this.assertText('7-8');
-
-      assert.strictEqual(barCopyDidChangeCount, 2, 'expected observer firing for: barCopy');
-    }
-
     ['@test overriding didReceiveAttrs does not trigger deprecation'](assert) {
       this.registerComponent('foo-bar', {
         ComponentClass: class extends Component {

packages/@ember/-internals/metal/tests/accessors/get_test.js

@@ -1,10 +1,8 @@
 import { ENV } from '@ember/-internals/environment';
-import EmberObject, { observer } from '@ember/object';
+import EmberObject from '@ember/object';
 import { get } from '../..';
-import Mixin from '@ember/object/mixin';
 import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
 import { run } from '@ember/runloop';
-import { destroy } from '@glimmer/destroyable';
 
 function aget(x, y) {
   return x[y];
@@ -179,29 +177,5 @@ moduleFor(
         /The key provided to get must be a string or number, you passed false/
       );
     }
-
-    // ..........................................................
-    // BUGS
-    //
-
-    ['@test (regression) watched properties on unmodified inherited objects should still return their original value'](
-      assert
-    ) {
-      let MyMixin = Mixin.create({
-        someProperty: 'foo',
-        propertyDidChange: observer('someProperty', () => {}),
-      });
-
-      let baseObject = MyMixin.apply({});
-      let theRealObject = Object.create(baseObject);
-
-      assert.equal(
-        get(theRealObject, 'someProperty'),
-        'foo',
-        'should return the set value, not false'
-      );
-
-      run(() => destroy(baseObject));
-    }
   }
 );

packages/@ember/-internals/metal/tests/observer_test.js

@@ -10,8 +10,6 @@ import {
   get,
   set,
 } from '..';
-import { observer } from '@ember/object';
-import Mixin, { mixin } from '@ember/object/mixin';
 import { moduleFor, AbstractTestCase, runLoopSettled } from 'internal-test-helpers';
 import { destroy } from '@glimmer/destroyable';
 import { meta as metaFor } from '@ember/-internals/meta';
@@ -35,40 +33,6 @@ moduleFor(
       }
     }
 
-    ['@test observer should assert to invalid input']() {
-      expectAssertion(() => {
-        observer(() => {});
-      }, 'observer called without valid path');
-
-      expectAssertion(() => {
-        observer(null);
-      }, 'observer must be provided a function or an observer definition');
-
-      expectAssertion(() => {
-        observer({});
-      }, 'observer called without a function');
-
-      expectAssertion(() => {
-        observer({
-          fn() {},
-        });
-      }, 'observer called without valid path');
-
-      expectAssertion(() => {
-        observer({
-          fn() {},
-          dependentKeys: [],
-        });
-      }, 'observer called without valid path');
-
-      expectAssertion(() => {
-        observer({
-          fn() {},
-          dependentKeys: ['foo'],
-        });
-      }, 'observer called without sync');
-    }
-
     async ['@test observer should fire when property is modified'](assert) {
       obj = {};
       let count = 0;
@@ -189,79 +153,6 @@ moduleFor(
       assert.equal(observerCount, 10, 'should continue to fire indefinitely');
     }
 
-    async ['@test observers watching multiple properties via brace expansion should fire when the properties change'](
-      assert
-    ) {
-      obj = {};
-      let count = 0;
-
-      mixin(obj, {
-        observeFooAndBar: observer('{foo,bar}', function () {
-          count++;
-        }),
-      });
-
-      set(obj, 'foo', 'foo');
-      await runLoopSettled();
-
-      assert.equal(count, 1, 'observer specified via brace expansion invoked on property change');
-
-      set(obj, 'bar', 'bar');
-      await runLoopSettled();
-
-      assert.equal(count, 2, 'observer specified via brace expansion invoked on property change');
-
-      set(obj, 'baz', 'baz');
-      await runLoopSettled();
-
-      assert.equal(count, 2, 'observer not invoked on unspecified property');
-    }
-
-    async ['@test observers watching multiple properties via brace expansion should fire when dependent properties change'](
-      assert
-    ) {
-      obj = { baz: 'Initial' };
-      let count = 0;
-
-      defineProperty(
-        obj,
-        'foo',
-        computed('bar', function () {
-          return get(this, 'bar').toLowerCase();
-        })
-      );
-
-      defineProperty(
-        obj,
-        'bar',
-        computed('baz', function () {
-          return get(this, 'baz').toUpperCase();
-        })
-      );
-
-      mixin(obj, {
-        fooAndBarWatcher: observer('{foo,bar}', function () {
-          count++;
-        }),
-      });
-
-      get(obj, 'foo');
-      set(obj, 'baz', 'Baz');
-      await runLoopSettled();
-
-      // fire once for foo, once for bar
-      assert.equal(
-        count,
-        2,
-        'observer specified via brace expansion invoked on dependent property change'
-      );
-
-      set(obj, 'quux', 'Quux');
-      await runLoopSettled();
-
-      assert.equal(count, 2, 'observer not fired on unspecified property');
-    }
-
     async ['@test removing an chain observer on change should not fail'](assert) {
       let foo = { bar: 'bar' };
       let obj1 = { foo: foo };
@@ -433,36 +324,6 @@ moduleFor(
       assert.equal(count, 1, "removed observer shouldn't fire");
     }
 
-    async ['@test local observers can be removed'](assert) {
-      let barObserved = 0;
-
-      let MyMixin = Mixin.create({
-        foo1: observer('bar', function () {
-          barObserved++;
-        }),
-
-        foo2: observer('bar', function () {
-          barObserved++;
-        }),
-      });
-
-      obj = {};
-      MyMixin.apply(obj);
-
-      set(obj, 'bar', 'HI!');
-      await runLoopSettled();
-
-      assert.equal(barObserved, 2, 'precond - observers should be fired');
-
-      removeObserver(obj, 'bar', null, 'foo1');
-
-      barObserved = 0;
-      set(obj, 'bar', 'HI AGAIN!');
-      await runLoopSettled();
-
-      assert.equal(barObserved, 1, 'removed observers should not be called');
-    }
-
     async ['@test removeObserver should respect targets with methods'](assert) {
       let observed = { foo: 'foo' };
 

packages/@ember/-internals/runtime/tests/system/core_object_test.js

@@ -1,13 +1,7 @@
 import { getOwner, setOwner } from '@ember/-internals/owner';
-import { get, set, observer } from '@ember/object';
+import { get, set } from '@ember/object';
 import CoreObject from '@ember/object/core';
-import {
-  moduleFor,
-  AbstractTestCase,
-  buildOwner,
-  runDestroy,
-  runLoopSettled,
-} from 'internal-test-helpers';
+import { moduleFor, AbstractTestCase, buildOwner, runDestroy } from 'internal-test-helpers';
 import { track } from '@glimmer/validator';
 import { destroy } from '@glimmer/destroyable';
 import { run } from '@ember/runloop';
@@ -97,32 +91,6 @@ moduleFor(
       TestObj.create(options);
     }
 
-    async ['@test observed properties are enumerable when set GH#14594'](assert) {
-      let callCount = 0;
-      let Test = CoreObject.extend({
-        myProp: null,
-        anotherProp: undefined,
-        didChangeMyProp: observer('myProp', function () {
-          callCount++;
-        }),
-      });
-
-      let test = Test.create();
-      set(test, 'id', '3');
-      set(test, 'myProp', { id: 1 });
-
-      assert.deepEqual(Object.keys(test).sort(), ['id', 'myProp']);
-
-      set(test, 'anotherProp', 'nice');
-
-      assert.deepEqual(Object.keys(test).sort(), ['anotherProp', 'id', 'myProp']);
-      await runLoopSettled();
-
-      assert.equal(callCount, 1);
-
-      test.destroy();
-    }
-
     ['@test native getters/setters do not cause rendering invalidation during init'](assert) {
       let objectMeta = Object.create(null);