Merge pull request #103 from pzuraq/refactor-to-use-storage-primitives

Refactor to use TrackedStorage

Author: pzuraq

.eslintrc.js

@@ -11,11 +11,12 @@ module.exports = {
     }
   },
   plugins: [
-    'ember'
+    'ember',
+    '@typescript-eslint'
   ],
   extends: [
     'eslint:recommended',
-    'plugin:ember/recommended'
+    'plugin:ember/recommended',
   ],
   env: {
     browser: true
@@ -54,6 +55,24 @@ module.exports = {
       rules: Object.assign({}, require('eslint-plugin-node').configs.recommended.rules, {
         // add your custom rules and overrides for node files here
       })
+    },
+    // TS
+    {
+      files: ['**/*.ts'],
+      extends: [
+        'plugin:@typescript-eslint/recommended',
+      ],
+      rules: {
+        '@typescript-eslint/ban-types': [
+          'error',
+          {
+            extendDefaults: true,
+            types: {
+              object: false,
+            }
+          }
+        ]
+      }
     }
   ]
 };

.github/workflows/CI.yml

@@ -30,7 +30,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: ['10', '12', '14']
+        node-version: ['12', '14']
 
     steps:
       - uses: actions/checkout@v2
@@ -62,7 +62,7 @@ jobs:
     strategy:
       matrix:
         ember-version:
-          ['lts-3.16', 'lts-3.20', 'lts-3.24', 'release', 'beta', 'canary']
+          ['lts-3.24', 'release', 'beta', 'canary']
 
     steps:
       - uses: actions/checkout@v2

config/ember-try.js

@@ -13,22 +13,6 @@ module.exports = async function () {
   return {
     useYarn: true,
     scenarios: [
-      {
-        name: 'ember-lts-3.16',
-        npm: {
-          devDependencies: {
-            'ember-source': '~3.16.10',
-          },
-        },
-      },
-      {
-        name: 'ember-lts-3.20',
-        npm: {
-          devDependencies: {
-            'ember-source': '~3.20.6',
-          },
-        },
-      },
       {
         name: 'ember-lts-3.24',
         npm: {

package.json

@@ -33,8 +33,10 @@
     "prepare": "yarn build:ts"
   },
   "dependencies": {
+    "@ember/test-helpers": "^2.3.0",
     "@glimmer/tracking": "^1.0.0",
-    "ember-cli-babel": "^7.26.5"
+    "ember-cli-babel": "^7.26.5",
+    "qunit": "^2.16.0"
   },
   "devDependencies": {
     "@ember/optional-features": "^2.0.0",
@@ -44,6 +46,7 @@
     "@types/ember__test-helpers": "^2.0.0",
     "@types/qunit": "^2.11.1",
     "@types/rsvp": "^4.0.3",
+    "@typescript-eslint/eslint-plugin": "^4.29.0",
     "@typescript-eslint/parser": "^4.23.0",
     "broccoli-asset-rev": "^3.0.0",
     "ember-cli": "~3.27.0",
@@ -58,10 +61,11 @@
     "ember-export-application-global": "^2.0.1",
     "ember-load-initializers": "^2.1.1",
     "ember-maybe-import-regenerator": "^0.1.6",
-    "ember-qunit": "^4.6.0",
+    "ember-qunit": "^5.1.4",
     "ember-resolver": "^8.0.2",
     "ember-source": "~3.27.1",
     "ember-source-channel-url": "^3.0.0",
+    "ember-tracked-storage-polyfill": "1.0.0",
     "ember-try": "^1.4.0",
     "ember-welcome-page": "^4.0.0",
     "eslint": "^7.0.0",
@@ -75,7 +79,7 @@
     "typescript": "4.3.5"
   },
   "engines": {
-    "node": "10.* || >= 12"
+    "node": "12.* || >= 14"
   },
   "ember": {
     "edition": "octane"

src/-private/map.ts

@@ -1,115 +1,187 @@
 import {
-  consumeKey,
-  consumeCollection,
-  dirtyKey,
-  dirtyCollection
-} from './util';
+  TrackedStorage,
+  createStorage,
+  getValue,
+  setValue,
+} from 'ember-tracked-storage-polyfill';
+
+export class TrackedMap<K = unknown, V = unknown> implements Map<K, V> {
+  private collection = createStorage(null, () => false);
+
+  private storages: Map<K, TrackedStorage<null>> = new Map();
+
+  private vals: Map<K, V>;
+
+  private readStorageFor(key: K): void {
+    const { storages } = this;
+    let storage = storages.get(key);
+
+    if (storage === undefined) {
+      storage = createStorage(null, () => false);
+      storages.set(key, storage);
+    }
+
+    getValue(storage);
+  }
+
+  private dirtyStorageFor(key: K): void {
+    const storage = this.storages.get(key);
+
+    if (storage) {
+      setValue(storage, null);
+    }
+  }
+
+  constructor(entries?: readonly (readonly [K, V])[] | null) {
+    this.vals = new Map(entries);
+  }
 
-export class TrackedMap<K = unknown, V = unknown> extends Map<K, V> {
   // **** KEY GETTERS ****
-  get(key: K) {
-    consumeKey(this, key);
+  get(key: K): V | undefined {
+    // entangle the storage for the key
+    this.readStorageFor(key);
 
-    return super.get(key);
+    return this.vals.get(key);
   }
 
-  has(key: K) {
-    consumeKey(this, key);
+  has(key: K): boolean {
+    this.readStorageFor(key);
 
-    return super.has(key);
+    return this.vals.has(key);
   }
 
   // **** ALL GETTERS ****
-  entries() {
-    consumeCollection(this);
+  entries(): IterableIterator<[K, V]> {
+    getValue(this.collection);
 
-    return super.entries();
+    return this.vals.entries();
   }
 
-  keys() {
-    consumeCollection(this);
+  keys(): IterableIterator<K> {
+    getValue(this.collection);
 
-    return super.keys();
+    return this.vals.keys();
   }
 
-  values() {
-    consumeCollection(this);
+  values(): IterableIterator<V> {
+    getValue(this.collection);
 
-    return super.values();
+    return this.vals.values();
   }
 
-  forEach(fn: (value: V, key: K, map: this) => void) {
-    consumeCollection(this);
+  forEach(fn: (value: V, key: K, map: Map<K, V>) => void): void {
+    getValue(this.collection);
 
-    super.forEach(fn);
+    this.vals.forEach(fn);
   }
 
-  get size() {
-    consumeCollection(this);
+  get size(): number {
+    getValue(this.collection);
+
+    return this.vals.size;
+  }
+
+  [Symbol.iterator](): IterableIterator<[K, V]> {
+    getValue(this.collection);
+
+    return this.vals[Symbol.iterator]();
+  }
 
-    return super.size;
+  get [Symbol.toStringTag](): string {
+    return this.vals[Symbol.toStringTag];
   }
 
   // **** KEY SETTERS ****
-  set(key: K, value: V) {
-    dirtyKey(this, key);
-    dirtyCollection(this);
+  set(key: K, value: V): this {
+    this.dirtyStorageFor(key);
+    setValue(this.collection, null);
+
+    this.vals.set(key, value);
 
-    return super.set(key, value);
+    return this;
   }
 
-  delete(key: K) {
-    dirtyKey(this, key);
-    dirtyCollection(this);
+  delete(key: K): boolean {
+    this.dirtyStorageFor(key);
+    setValue(this.collection, null);
 
-    return super.delete(key);
+    return this.vals.delete(key);
   }
 
   // **** ALL SETTERS ****
-  clear() {
-    super.forEach((_v, k) => dirtyKey(this, k));
-    dirtyCollection(this);
+  clear(): void {
+    this.storages.forEach((s) => setValue(s, null));
+    setValue(this.collection, null);
 
-    return super.clear();
+    this.vals.clear();
   }
 }
 
-if (typeof Symbol !== undefined) {
-  let originalIterator = TrackedMap.prototype[Symbol.iterator];
+// So instanceof works
+Object.setPrototypeOf(TrackedMap, Map.prototype);
+
+export class TrackedWeakMap<
+  K extends object = object,
+  V = unknown
+> implements WeakMap<K, V> {
+  private storages: WeakMap<K, TrackedStorage<null>> = new WeakMap();
+
+  private vals: WeakMap<K, V>;
+
+  private readStorageFor(key: K): void {
+    const { storages } = this;
+    let storage = storages.get(key);
 
-  Object.defineProperty(TrackedMap.prototype, Symbol.iterator, {
-    get() {
-      consumeCollection(this);
-      return originalIterator;
+    if (storage === undefined) {
+      storage = createStorage(null, () => false);
+      storages.set(key, storage);
     }
-  });
-}
 
-export class TrackedWeakMap<K extends object = object, V = unknown> extends WeakMap<
-  K,
-  V
-> {
-  get(key: K) {
-    consumeKey(this, key);
+    getValue(storage);
+  }
+
+  private dirtyStorageFor(key: K): void {
+    const storage = this.storages.get(key);
+
+    if (storage) {
+      setValue(storage, null);
+    }
+  }
 
-    return super.get(key);
+  constructor(iterable?: (readonly [K, V][] | null)) {
+    this.vals = new WeakMap(iterable);
   }
 
-  has(key: K) {
-    consumeKey(this, key);
+  get(key: K): V | undefined {
+    this.readStorageFor(key);
 
-    return super.has(key);
+    return this.vals.get(key);
   }
 
-  set(key: K, value: V) {
-    dirtyKey(this, key);
+  has(key: K): boolean {
+    this.readStorageFor(key);
 
-    return super.set(key, value);
+    return this.vals.has(key);
   }
 
-  delete(key: K) {
-    dirtyKey(this, key);
+  set(key: K, value: V): this {
+    this.dirtyStorageFor(key);
+
+    this.vals.set(key, value);
 
-    return super.delete(key);
+    return this;
+  }
+
+  delete(key: K): boolean {
+    this.dirtyStorageFor(key);
+
+    return this.vals.delete(key);
+  }
+
+  get [Symbol.toStringTag](): string {
+    return this.vals[Symbol.toStringTag];
   }
 }
+
+// So instanceof works
+Object.setPrototypeOf(TrackedWeakMap, WeakMap.prototype);