[MAJOR]: rewrite for v3

.eslintrc.js

@@ -1,8 +1,12 @@
 module.exports = {
   root: true,
+  parser: 'babel-eslint',
   parserOptions: {
-    ecmaVersion: 2017,
-    sourceType: 'module'
+    ecmaVersion: 2018,
+    sourceType: 'module',
+    ecmaFeatures: {
+      legacyDecorators: true
+    }
   },
   plugins: [
     'ember'
@@ -15,13 +19,14 @@ module.exports = {
     browser: true
   },
   rules: {
-    'ember/avoid-leaking-state-in-ember-objects': 0
+    'ember/no-jquery': 'error'
   },
   overrides: [
     // node files
     {
       files: [
         '.eslintrc.js',
+        '.template-lintrc.js',
         'ember-cli-build.js',
         'index.js',
         'testem.js',
@@ -36,8 +41,7 @@ module.exports = {
         'tests/dummy/app/**'
       ],
       parserOptions: {
-        sourceType: 'script',
-        ecmaVersion: 2015
+        sourceType: 'script'
       },
       env: {
         browser: false,

.npmignore

@@ -8,10 +8,11 @@
 # misc
 /.bowerrc
 /.editorconfig
-/.ember-cli
+/.ember-cli.js
 /.env*
 /.eslintignore
 /.eslintrc.js
+/.git/
 /.gitignore
 /.template-lintrc.js
 /.travis.yml

.travis.yml

@@ -38,7 +38,8 @@ jobs:
       install:
         - yarn install --non-interactive
       script:
-        - yarn lint
+        - yarn lint:hbs
+        - yarn lint:js
         - yarn test
 
     - name: "Floating Dependencies"
@@ -48,8 +49,6 @@ jobs:
     # we recommend new addons test the current and previous LTS
     # as well as latest stable release (bonus points to beta/canary)
     - stage: "Additional Tests"
-      env: EMBER_TRY_SCENARIO=ember-lts-2.18
-    - env: EMBER_TRY_SCENARIO=ember-lts-3.4
     - env: EMBER_TRY_SCENARIO=ember-release
     - env: EMBER_TRY_SCENARIO=ember-beta
     - env: EMBER_TRY_SCENARIO=ember-canary

addon/-private/evented.ts

@@ -0,0 +1,15 @@
+import Notifier from './notifier';
+
+export function notifierForEvent(object: any, eventName: string) {
+  if (object._eventedNotifiers === undefined) {
+    object._eventedNotifiers = {};
+  }
+
+  let notifier = object._eventedNotifiers[eventName];
+
+  if (!notifier) {
+    notifier = object._eventedNotifiers[eventName] = new Notifier();
+  }
+
+  return notifier;
+}

addon/-private/get-deep.ts

@@ -0,0 +1,19 @@
+export default function getDeep<T extends object>(root: T, path: string | string[]): any {
+  let obj: any = root;
+
+  if (path.indexOf('.') === -1) {
+    return obj[path as string];
+  }
+  let parts = typeof path === 'string' ? path.split('.') : path;
+
+  for (let i = 0; i < parts.length; i++) {
+    if (obj === undefined || obj === null) {
+      return undefined;
+    }
+
+    // next iteration has next level
+    obj = obj[parts[i]];
+  }
+
+  return obj;
+}

addon/-private/key-values.ts

@@ -0,0 +1,29 @@
+import isObject from '../utils/is-object';
+
+// 'foo.bar.zaz'
+let keysUpToValue: any[] = [];
+
+/**
+ * traverse through target and return leaf nodes with `value` property
+ *
+ * @method keyValues
+ * @param target
+ */
+export default function keyValues<T extends { [key: string]: any}>(obj: T): object[] {
+  let map = [];
+  for (let key in obj) {
+    keysUpToValue.push(key);
+
+    if (obj[key] && isObject(obj[key])) {
+      if (Object.prototype.hasOwnProperty.apply(obj[key], ['value'])) {
+        map.push({ key: keysUpToValue.join('.'), value: obj[key].value });
+        // stop collecting keys
+        keysUpToValue = [];
+      } else if (key !== 'value') {
+        map.push(...keyValues(obj[key]));
+      }
+    }
+  }
+
+  return map;
+}

addon/-private/merge-deep.ts

@@ -0,0 +1,132 @@
+interface Options {
+  safeGet: any
+  safeSet: any
+}
+
+function isMergeableObject(value: any): Boolean {
+  return isNonNullObject(value) && !isSpecial(value);
+}
+
+function isNonNullObject(value: any): Boolean {
+  return !!value && typeof value === 'object';
+}
+
+function isSpecial(value: any): Boolean {
+  let stringValue = Object.prototype.toString.call(value);
+
+  return stringValue === '[object RegExp]' || stringValue === '[object Date]';
+}
+
+function getEnumerableOwnPropertySymbols(target: any): any {
+	return Object.getOwnPropertySymbols
+		? Object.getOwnPropertySymbols(target).filter(symbol => {
+			return target.propertyIsEnumerable(symbol)
+		})
+		: [];
+}
+
+function getKeys(target: any) {
+	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
+}
+
+function propertyIsOnObject(object: any, property: any) {
+	try {
+		return property in object;
+	} catch(_) {
+		return false;
+	}
+}
+
+// Protects from prototype poisoning and unexpected merging up the prototype chain.
+function propertyIsUnsafe(target: any, key: string): Boolean {
+  return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
+		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
+    && Object.propertyIsEnumerable.call(target, key)); // and also unsafe if they're nonenumerable.
+}
+
+let kv: { [k: string]: any } = {};
+let possibleKeys: string[] = [];
+
+/**
+ * DFS - traverse depth first until find object with `value`.  Then go back up tree and try on next key
+ * need to exhaust all possible avenues.
+ *
+ * @method buildPathToValue
+ */
+function buildPathToValue(source: any, options: Options): void {
+  Object.keys(source).forEach((key: string): void => {
+    let possible = source[key];
+    if (possible && possible.hasOwnProperty('value')) {
+      possibleKeys.push(key);
+      kv[possibleKeys.join('.')] = possible.value;
+      possibleKeys = [];
+      return;
+    }
+
+    if (typeof possible === 'object') {
+      possibleKeys.push(key);
+      buildPathToValue(possible, options);
+    } else {
+      possibleKeys = [];
+    }
+  });
+}
+
+/**
+ * `source` will always have a leaf key `value` with the proeprty we want to set
+ * @method mergeObject
+ */
+function mergeObject(target: any, source: any, options: Options) {
+	getKeys(source).forEach(key => {
+    // proto poisoning.  So can set by nested key path 'person.name'
+		if (propertyIsUnsafe(target, key)) {
+      if (options.safeSet) {
+        buildPathToValue(source, options);
+        if (Object.keys(kv).length > 0) {
+          // we found some keys!
+          for (key in kv) {
+            const val = kv[key];
+            options.safeSet(target, key, val);
+          }
+        }
+
+        kv = {};
+      }
+
+			return;
+		}
+
+    // else safe key on object
+		if (propertyIsOnObject(target, key) && isMergeableObject(source[key]) && !source[key].hasOwnProperty('value')) {
+			target[key] = mergeDeep(options.safeGet(target, key), options.safeGet(source, key), options);
+		} else {
+      return target[key] = source[key].value;
+		}
+  });
+
+	return target;
+}
+
+/**
+ * goal is to mutate target with source's properties, ensuring we dont encounter
+ * pitfalls of { ..., ... } spread syntax overwriting keys on objects that we merged
+ *
+ * @method mergeDeep
+ * @param target
+ * @param source
+ */
+export default function mergeDeep(target: any, source: any, options: Options = { safeGet: undefined, safeSet: undefined }): object | [any] {
+	options['safeGet'] = options.safeGet || function(obj: any, key: string): any { return obj[key] };
+	options['safeSet'] = options.safeSet;
+	let sourceIsArray = Array.isArray(source);
+	let targetIsArray = Array.isArray(target);
+	let sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+
+	if (!sourceAndTargetTypesMatch) {
+		return source;
+	} else if (sourceIsArray) {
+		return source;
+	} else {
+		return mergeObject(target, source, options);
+	}
+}

addon/-private/normalize-object.ts

@@ -0,0 +1,29 @@
+import isObject from '../utils/is-object';
+
+/**
+ * traverse through target and unset `value` from leaf key
+ * Shallow copy here is fine because we are swapping out the leaf nested object
+ * rather than mutating a property in something with reference
+ *
+ * @method normalizeObject
+ * @param target
+ */
+export default function normalizeObject<T extends { [key: string]: any}>(target: T): T {
+  let obj = { ...target };
+
+  for (let key in obj) {
+    if (key === 'value') {
+      return obj[key];
+    }
+
+    if (obj[key] && isObject(obj[key])) {
+      if (Object.prototype.hasOwnProperty.apply(obj[key], ['value'])) {
+        obj[key] = obj[key].value;
+      } else {
+        obj[key] = normalizeObject(obj[key]);
+      }
+    }
+  }
+
+  return obj;
+}

addon/-private/notifier.ts

@@ -0,0 +1,30 @@
+// this statefull class holds and notifies
+import { INotifier } from '../types/evented';
+
+export default class Notifier implements INotifier {
+  listeners: Function[]
+
+  constructor() {
+    this.listeners = [];
+  }
+
+  addListener(callback: Function) {
+    this.listeners.push(callback);
+    return () => this.removeListener(callback);
+  }
+
+  removeListener(callback: Function) {
+    this.listeners;
+
+    for (let i = 0; i < this.listeners.length; i++) {
+      if (this.listeners[i] === callback) {
+        this.listeners.splice(i, 1);
+        return;
+      }
+    }
+  }
+
+  trigger(...args: any[]) {
+    this.listeners.slice(0).forEach(callback => callback(...args));
+  }
+}