Wip, Implement experiment for: emberjs/rfcs#905

Author: NullVoxPopuli

.changeset/hip-fishes-agree.md

@@ -0,0 +1,72 @@
+---
+"ember-resources": minor
+---
+
+Add link() and @link
+
+<details><summary>Example property usage</summary>
+
+```js
+import { link } from 'ember-resources/link';
+
+class MyClass {  ... }
+
+export default class Demo extends Component {
+  // This usage does now allow passing args to `MyClass`
+  @link(MyClass) myInstance;
+}
+```
+
+</details>
+
+<details><summary>Example inline usage</summary>
+
+```js
+import Component from '@glimmer/component';
+import { cached } from '@glimmer/tracking';
+import { link } from 'ember-resources/link';
+
+export default class Demo extends Component {
+  // To pass args to `MyClass`, you must use this form
+  // NOTE though, that `instance` is linked to the `Demo`s lifecycle.
+  //  So if @foo is changing frequently, memory pressure will increase rapidly
+  //  until the `Demo` instance is destroyed.
+  // 
+  //  Resources are a better fit for this use case, as they won't add to memory pressure.
+  @cached
+  get myFunction() {
+    let instance = new MyClass(this.args.foo);
+
+    return link(instance, this);
+  }
+}
+```
+
+</details>
+
+
+This abstracts away the following boilerplate:
+```js 
+import { getOwner, setOwner } from '@ember/owner';
+import { associateDestroyableChild } from '@ember/destroyable';
+
+class MyClass { /* ... */ }
+
+export default class Demo extends Component {
+  @cached 
+  get myInstance() {
+    let instance = new MyClass();
+    
+    associateDestroyableChild(this, instance);
+    
+    let owner = getOwner(this);
+
+    if (owner) {
+      setOwner(instance, owner);
+    }
+
+    return instance;
+  }
+}
+```
+

ember-resources/src/util/link.ts

@@ -0,0 +1,77 @@
+import { getOwner, setOwner } from "@ember/application";
+import { assert } from "@ember/debug";
+import { associateDestroyableChild } from "@ember/destroyable";
+
+/**
+  * A util to abstract away the boilerplate of linking of "things" with an owner
+  * and making them destroyable.
+  *
+  *
+  * Example as a class property:
+  * ```js
+  * import { link } from 'ember-resources/link';
+  *
+  * class MyClass {  ... }
+  *
+  * export default class Demo extends Component {
+  *   @link(MyClass) myInstance;
+  * }
+  * ```
+  *
+  * Example inline usage:
+  * ```js
+  * import Component from '@glimmer/component';
+  * import { cached } from '@glimmer/tracking';
+  * import { link } from 'ember-resources/link';
+  *
+  * export default class Demo extends Component {
+  *   @cached
+  *   get myFunction() {
+  *     let instance = new MyClass(this.args.foo);
+  *
+  *     return link(instance, this);
+  *   }
+  * }
+  * ```
+  */
+function link(_prototype: object, key: string, descriptor?: Descriptor): void {
+  if (!descriptor) return;
+
+  assert(`@link can only be used with string-keys`, typeof key === 'string');
+
+
+  let { initializer } = descriptor;
+
+  assert(
+    `@link may only be used on initialized properties. For example, ` +
+      `\`@link foo = new MyClass();\``,
+    initializer
+  );
+
+
+  let caches = new WeakMap<object, any>();
+
+  // https://github.com/pzuraq/ember-could-get-used-to-this/blob/master/addon/index.js
+  return {
+    get(this: object) {
+      let child = caches.get(this);
+
+      if (!child) {
+        child = initializer.call(this);
+
+        associateDestroyableChild(this, child);
+
+        let owner = getOwner(this);
+
+        if (owner) {
+          setOwner(child, owner);
+        }
+
+        caches.set(this, child);
+        assert(`Failed to create cache for internal resource configuration object`, child);
+      }
+
+      return child;
+    },
+  } as unknown as void /* Thanks TS. */;
+}