discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-meta/tests/meta_test.js

@@ -1,169 +0,0 @@
-import { AbstractTestCase, moduleFor } from 'internal-test-helpers';
-import { meta } from '..';
-
-moduleFor(
-  'Ember.meta',
-  class extends AbstractTestCase {
-    ['@test should return the same hash for an object'](assert) {
-      let obj = {};
-
-      meta(obj).foo = 'bar';
-
-      assert.equal(meta(obj).foo, 'bar', 'returns same hash with multiple calls to Ember.meta()');
-    }
-
-    ['@test meta is not enumerable'](assert) {
-      let proto, obj, props, prop;
-      proto = { foo: 'bar' };
-      meta(proto);
-      obj = Object.create(proto);
-      meta(obj);
-      obj.bar = 'baz';
-      props = [];
-      for (prop in obj) {
-        props.push(prop);
-      }
-      assert.deepEqual(props.sort(), ['bar', 'foo']);
-      if (typeof JSON !== 'undefined' && 'stringify' in JSON) {
-        try {
-          JSON.stringify(obj);
-        } catch (e) {
-          assert.ok(false, 'meta should not fail JSON.stringify');
-        }
-      }
-    }
-
-    ['@test meta.listeners basics'](assert) {
-      let t = {};
-      let m = meta({});
-      m.addToListeners('hello', t, 'm', 0);
-      let matching = m.matchingListeners('hello');
-      assert.equal(matching.length, 3);
-      assert.equal(matching[0], t);
-      m.removeFromListeners('hello', t, 'm');
-      matching = m.matchingListeners('hello');
-      assert.equal(matching, undefined);
-    }
-
-    ['@test meta.listeners inheritance'](assert) {
-      let target = {};
-      let parent = {};
-      let parentMeta = meta(parent);
-      parentMeta.addToListeners('hello', target, 'm', 0);
-
-      let child = Object.create(parent);
-      let m = meta(child);
-
-      let matching = m.matchingListeners('hello');
-      assert.equal(matching.length, 3);
-      assert.equal(matching[0], target);
-      assert.equal(matching[1], 'm');
-      assert.equal(matching[2], 0);
-      m.removeFromListeners('hello', target, 'm');
-      matching = m.matchingListeners('hello');
-      assert.equal(matching, undefined);
-      matching = parentMeta.matchingListeners('hello');
-      assert.equal(matching.length, 3);
-    }
-
-    ['@test meta.listeners deduplication'](assert) {
-      let t = {};
-      let m = meta({});
-      m.addToListeners('hello', t, 'm', 0);
-      m.addToListeners('hello', t, 'm', 0);
-      let matching = m.matchingListeners('hello');
-      assert.equal(matching.length, 3);
-      assert.equal(matching[0], t);
-    }
-
-    ['@test meta.writeWatching issues useful error after destroy']() {
-      let target = {
-        toString() {
-          return '<special-sauce:123>';
-        },
-      };
-      let targetMeta = meta(target);
-
-      targetMeta.destroy();
-
-      expectAssertion(() => {
-        targetMeta.writeWatching('hello', 1);
-      }, 'Cannot update watchers for `hello` on `<special-sauce:123>` after it has been destroyed.');
-    }
-
-    ['@test meta.writableTag issues useful error after destroy']() {
-      let target = {
-        toString() {
-          return '<special-sauce:123>';
-        },
-      };
-      let targetMeta = meta(target);
-
-      targetMeta.destroy();
-
-      expectAssertion(() => {
-        targetMeta.writableTag(() => {});
-      }, 'Cannot create a new tag for `<special-sauce:123>` after it has been destroyed.');
-    }
-
-    ['@test meta.writableChainWatchers issues useful error after destroy']() {
-      let target = {
-        toString() {
-          return '<special-sauce:123>';
-        },
-      };
-      let targetMeta = meta(target);
-
-      targetMeta.destroy();
-
-      expectAssertion(() => {
-        targetMeta.writableChainWatchers(() => {});
-      }, 'Cannot create a new chain watcher for `<special-sauce:123>` after it has been destroyed.');
-    }
-
-    ['@test meta.writableChains issues useful error after destroy']() {
-      let target = {
-        toString() {
-          return '<special-sauce:123>';
-        },
-      };
-      let targetMeta = meta(target);
-
-      targetMeta.destroy();
-
-      expectAssertion(() => {
-        targetMeta.writableChains(() => {});
-      }, 'Cannot create a new chains for `<special-sauce:123>` after it has been destroyed.');
-    }
-
-    ['@test meta.writeValues issues useful error after destroy']() {
-      let target = {
-        toString() {
-          return '<special-sauce:123>';
-        },
-      };
-      let targetMeta = meta(target);
-
-      targetMeta.destroy();
-
-      expectAssertion(() => {
-        targetMeta.writeValues('derp', 'ohai');
-      }, 'Cannot set the value of `derp` on `<special-sauce:123>` after it has been destroyed.');
-    }
-
-    ['@test meta.writeDeps issues useful error after destroy']() {
-      let target = {
-        toString() {
-          return '<special-sauce:123>';
-        },
-      };
-      let targetMeta = meta(target);
-
-      targetMeta.destroy();
-
-      expectAssertion(() => {
-        targetMeta.writeDeps('derp', 'ohai', 1);
-      }, 'Cannot modify dependent keys for `ohai` on `<special-sauce:123>` after it has been destroyed.');
-    }
-  }
-);

data/dist/es/ember-metal/index.js

@@ -1,33 +0,0 @@
-export { default as computed, ComputedProperty, _globalsComputed } from './lib/computed';
-export { getCacheFor, getCachedValueFor, peekCacheFor } from './lib/computed_cache';
-export { default as alias } from './lib/alias';
-export { deprecateProperty } from './lib/deprecate_property';
-export { PROXY_CONTENT, _getPath, get, getWithDefault } from './lib/property_get';
-export { set, trySet } from './lib/property_set';
-export { objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, } from './lib/array';
-export { arrayContentWillChange, arrayContentDidChange } from './lib/array_events';
-export { eachProxyFor } from './lib/each_proxy';
-export { eachProxyArrayWillChange, eachProxyArrayDidChange } from './lib/each_proxy_events';
-export { addListener, hasListeners, on, removeListener, sendEvent } from './lib/events';
-export { default as isNone } from './lib/is_none';
-export { default as isEmpty } from './lib/is_empty';
-export { default as isBlank } from './lib/is_blank';
-export { default as isPresent } from './lib/is_present';
-export { beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, overrideChains, propertyDidChange, propertyWillChange, PROPERTY_DID_CHANGE, } from './lib/property_events';
-export { defineProperty, Descriptor } from './lib/properties';
-export { watchKey, unwatchKey } from './lib/watch_key';
-export { ChainNode, finishChains, removeChainWatcher } from './lib/chains';
-export { watchPath, unwatchPath } from './lib/watch_path';
-export { isWatching, unwatch, watch, watcherCount } from './lib/watching';
-export { default as libraries, Libraries } from './lib/libraries';
-export { default as getProperties } from './lib/get_properties';
-export { default as setProperties } from './lib/set_properties';
-export { default as expandProperties } from './lib/expand_properties';
-export { addObserver, removeObserver } from './lib/observer';
-export { Mixin, aliasMethod, mixin, observer, applyMixin } from './lib/mixin';
-export { default as InjectedProperty } from './lib/injected_property';
-export { setHasViews, tagForProperty, tagFor, markObjectAsDirty } from './lib/tags';
-export { default as runInTransaction, didRender, assertNotRendered } from './lib/transaction';
-export { default as descriptor } from './lib/descriptor';
-export { tracked } from './lib/tracked';
-export { NAMESPACES, NAMESPACES_BY_ID, addNamespace, classToString, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled, } from './lib/namespace_search';

data/dist/es/ember-metal/lib/alias.js

@@ -1,80 +0,0 @@
-import { assert } from '@ember/debug';
-import EmberError from '@ember/error';
-import { meta as metaFor } from 'ember-meta';
-import { inspect } from 'ember-utils';
-import { ComputedProperty } from './computed';
-import { getCachedValueFor, getCacheFor } from './computed_cache';
-import { addDependentKeys, removeDependentKeys, } from './dependent_keys';
-import { defineProperty, Descriptor } from './properties';
-import { get } from './property_get';
-import { set } from './property_set';
-const CONSUMED = Object.freeze({});
-export default function alias(altKey) {
-    return new AliasedProperty(altKey);
-}
-export class AliasedProperty extends Descriptor {
-    constructor(altKey) {
-        super();
-        this.altKey = altKey;
-        this._dependentKeys = [altKey];
-    }
-    setup(obj, keyName) {
-        assert(`Setting alias '${keyName}' on self`, this.altKey !== keyName);
-        let meta = metaFor(obj);
-        if (meta.peekWatching(keyName) > 0) {
-            this.consume(obj, keyName, meta);
-        }
-    }
-    teardown(obj, keyName, meta) {
-        this.unconsume(obj, keyName, meta);
-    }
-    willWatch(obj, keyName, meta) {
-        this.consume(obj, keyName, meta);
-    }
-    didUnwatch(obj, keyName, meta) {
-        this.unconsume(obj, keyName, meta);
-    }
-    get(obj, keyName) {
-        let ret = get(obj, this.altKey);
-        this.consume(obj, keyName, metaFor(obj));
-        return ret;
-    }
-    unconsume(obj, keyName, meta) {
-        let wasConsumed = getCachedValueFor(obj, keyName) === CONSUMED;
-        if (wasConsumed || meta.peekWatching(keyName) > 0) {
-            removeDependentKeys(this, obj, keyName, meta);
-        }
-        if (wasConsumed) {
-            getCacheFor(obj).delete(keyName);
-        }
-    }
-    consume(obj, keyName, meta) {
-        let cache = getCacheFor(obj);
-        if (cache.get(keyName) !== CONSUMED) {
-            cache.set(keyName, CONSUMED);
-            addDependentKeys(this, obj, keyName, meta);
-        }
-    }
-    set(obj, _keyName, value) {
-        return set(obj, this.altKey, value);
-    }
-    readOnly() {
-        this.set = AliasedProperty_readOnlySet;
-        return this;
-    }
-    oneWay() {
-        this.set = AliasedProperty_oneWaySet;
-        return this;
-    }
-}
-function AliasedProperty_readOnlySet(obj, keyName) {
-    // eslint-disable-line no-unused-vars
-    throw new EmberError(`Cannot set read-only property '${keyName}' on object: ${inspect(obj)}`);
-}
-function AliasedProperty_oneWaySet(obj, keyName, value) {
-    defineProperty(obj, keyName, null);
-    return set(obj, keyName, value);
-}
-// Backwards compatibility with Ember Data.
-AliasedProperty.prototype._meta = undefined;
-AliasedProperty.prototype.meta = ComputedProperty.prototype.meta;

data/dist/es/ember-metal/lib/array.js

@@ -1,55 +0,0 @@
-import { arrayContentDidChange, arrayContentWillChange } from './array_events';
-import { addListener, removeListener } from './events';
-import { notifyPropertyChange } from './property_events';
-import { get } from './property_get';
-const EMPTY_ARRAY = Object.freeze([]);
-export function objectAt(array, index) {
-    if (Array.isArray(array)) {
-        return array[index];
-    }
-    else {
-        return array.objectAt(index);
-    }
-}
-export function replace(array, start, deleteCount, items = EMPTY_ARRAY) {
-    if (Array.isArray(array)) {
-        replaceInNativeArray(array, start, deleteCount, items);
-    }
-    else {
-        array.replace(start, deleteCount, items);
-    }
-}
-const CHUNK_SIZE = 60000;
-// To avoid overflowing the stack, we splice up to CHUNK_SIZE items at a time.
-// See https://code.google.com/p/chromium/issues/detail?id=56588 for more details.
-export function replaceInNativeArray(array, start, deleteCount, items) {
-    arrayContentWillChange(array, start, deleteCount, items.length);
-    if (items.length <= CHUNK_SIZE) {
-        array.splice(start, deleteCount, ...items);
-    }
-    else {
-        array.splice(start, deleteCount);
-        for (let i = 0; i < items.length; i += CHUNK_SIZE) {
-            let chunk = items.slice(i, i + CHUNK_SIZE);
-            array.splice(start + i, 0, ...chunk);
-        }
-    }
-    arrayContentDidChange(array, start, deleteCount, items.length);
-}
-function arrayObserversHelper(obj, target, opts, operation, notify) {
-    let willChange = (opts && opts.willChange) || 'arrayWillChange';
-    let didChange = (opts && opts.didChange) || 'arrayDidChange';
-    let hasObservers = get(obj, 'hasArrayObservers');
-    operation(obj, '@array:before', target, willChange);
-    operation(obj, '@array:change', target, didChange);
-    if (hasObservers === notify) {
-        notifyPropertyChange(obj, 'hasArrayObservers');
-    }
-    return obj;
-}
-export function addArrayObserver(array, target, opts) {
-    return arrayObserversHelper(array, target, opts, addListener, false);
-}
-export function removeArrayObserver(array, target, opts) {
-    return arrayObserversHelper(array, target, opts, removeListener, true);
-}

data/dist/es/ember-metal/lib/array_events.js

@@ -1,65 +0,0 @@
-import { peekMeta } from 'ember-meta';
-import { peekCacheFor } from './computed_cache';
-import { eachProxyArrayDidChange, eachProxyArrayWillChange } from './each_proxy_events';
-import { sendEvent } from './events';
-import { notifyPropertyChange } from './property_events';
-export function arrayContentWillChange(array, startIdx, removeAmt, addAmt) {
-    // if no args are passed assume everything changes
-    if (startIdx === undefined) {
-        startIdx = 0;
-        removeAmt = addAmt = -1;
-    }
-    else {
-        if (removeAmt === undefined) {
-            removeAmt = -1;
-        }
-        if (addAmt === undefined) {
-            addAmt = -1;
-        }
-    }
-    eachProxyArrayWillChange(array, startIdx, removeAmt, addAmt);
-    sendEvent(array, '@array:before', [array, startIdx, removeAmt, addAmt]);
-    return array;
-}
-export function arrayContentDidChange(array, startIdx, removeAmt, addAmt) {
-    // if no args are passed assume everything changes
-    if (startIdx === undefined) {
-        startIdx = 0;
-        removeAmt = addAmt = -1;
-    }
-    else {
-        if (removeAmt === undefined) {
-            removeAmt = -1;
-        }
-        if (addAmt === undefined) {
-            addAmt = -1;
-        }
-    }
-    let meta = peekMeta(array);
-    if (addAmt < 0 || removeAmt < 0 || addAmt - removeAmt !== 0) {
-        notifyPropertyChange(array, 'length', meta);
-    }
-    notifyPropertyChange(array, '[]', meta);
-    eachProxyArrayDidChange(array, startIdx, removeAmt, addAmt);
-    sendEvent(array, '@array:change', [array, startIdx, removeAmt, addAmt]);
-    let cache = peekCacheFor(array);
-    if (cache !== undefined) {
-        let length = array.length;
-        let addedAmount = addAmt === -1 ? 0 : addAmt;
-        let removedAmount = removeAmt === -1 ? 0 : removeAmt;
-        let delta = addedAmount - removedAmount;
-        let previousLength = length - delta;
-        let normalStartIdx = startIdx < 0 ? previousLength + startIdx : startIdx;
-        if (cache.has('firstObject') && normalStartIdx === 0) {
-            notifyPropertyChange(array, 'firstObject', meta);
-        }
-        if (cache.has('lastObject')) {
-            let previousLastIndex = previousLength - 1;
-            let lastAffectedIndex = normalStartIdx + removedAmount;
-            if (previousLastIndex < lastAffectedIndex) {
-                notifyPropertyChange(array, 'lastObject', meta);
-            }
-        }
-    }
-    return array;
-}

data/dist/es/ember-metal/lib/chains.js

@@ -1,315 +0,0 @@
-import { descriptorFor, meta as metaFor, peekMeta } from 'ember-meta';
-import { getCachedValueFor } from './computed_cache';
-import { eachProxyFor } from './each_proxy';
-import { get } from './property_get';
-import { unwatchKey, watchKey } from './watch_key';
-function isObject(obj) {
-    return typeof obj === 'object' && obj !== null;
-}
-function isVolatile(obj, keyName, meta) {
-    let desc = descriptorFor(obj, keyName, meta);
-    return !(desc !== undefined && desc._volatile === false);
-}
-class ChainWatchers {
-    constructor() {
-        // chain nodes that reference a key in this obj by key
-        // we only create ChainWatchers when we are going to add them
-        // so create this upfront
-        this.chains = Object.create(null);
-    }
-    add(key, node) {
-        let nodes = this.chains[key];
-        if (nodes === undefined) {
-            this.chains[key] = [node];
-        }
-        else {
-            nodes.push(node);
-        }
-    }
-    remove(key, node) {
-        let nodes = this.chains[key];
-        if (nodes !== undefined) {
-            for (let i = 0; i < nodes.length; i++) {
-                if (nodes[i] === node) {
-                    nodes.splice(i, 1);
-                    break;
-                }
-            }
-        }
-    }
-    has(key, node) {
-        let nodes = this.chains[key];
-        if (nodes !== undefined) {
-            for (let i = 0; i < nodes.length; i++) {
-                if (nodes[i] === node) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    revalidateAll() {
-        for (let key in this.chains) {
-            this.notify(key, true, undefined);
-        }
-    }
-    revalidate(key) {
-        this.notify(key, true, undefined);
-    }
-    // key: the string key that is part of a path changed
-    // revalidate: boolean; the chains that are watching this value should revalidate
-    // callback: function that will be called with the object and path that
-    //           will be/are invalidated by this key change, depending on
-    //           whether the revalidate flag is passed
-    notify(key, revalidate, callback) {
-        let nodes = this.chains[key];
-        if (nodes === undefined || nodes.length === 0) {
-            return;
-        }
-        let affected = undefined;
-        if (callback !== undefined) {
-            affected = [];
-        }
-        for (let i = 0; i < nodes.length; i++) {
-            nodes[i].notify(revalidate, affected);
-        }
-        if (callback === undefined) {
-            return;
-        }
-        // we gather callbacks so we don't notify them during revalidation
-        for (let i = 0; i < affected.length; i += 2) {
-            let obj = affected[i];
-            let path = affected[i + 1];
-            callback(obj, path);
-        }
-    }
-}
-function makeChainWatcher() {
-    return new ChainWatchers();
-}
-function makeChainNode(obj) {
-    return new ChainNode(null, null, obj);
-}
-function addChainWatcher(obj, keyName, node) {
-    let m = metaFor(obj);
-    m.writableChainWatchers(makeChainWatcher).add(keyName, node);
-    watchKey(obj, keyName, m);
-}
-function removeChainWatcher(obj, keyName, node, _meta) {
-    if (!isObject(obj)) {
-        return;
-    }
-    let meta = _meta === undefined ? peekMeta(obj) : _meta;
-    if (meta === undefined ||
-        meta.isSourceDestroying() ||
-        meta.isMetaDestroyed() ||
-        meta.readableChainWatchers() === undefined) {
-        return;
-    }
-    // make meta writable
-    meta = metaFor(obj);
-    meta.readableChainWatchers().remove(keyName, node);
-    unwatchKey(obj, keyName, meta);
-}
-const NODE_STACK = [];
-function destroyRoot(root) {
-    pushChildren(root);
-    while (NODE_STACK.length > 0) {
-        let node = NODE_STACK.pop();
-        pushChildren(node);
-        destroyOne(node);
-    }
-}
-function destroyOne(node) {
-    if (node.isWatching) {
-        removeChainWatcher(node.object, node.key, node);
-        node.isWatching = false;
-    }
-}
-function pushChildren(node) {
-    let nodes = node.chains;
-    if (nodes !== undefined) {
-        for (let key in nodes) {
-            if (nodes[key] !== undefined) {
-                NODE_STACK.push(nodes[key]);
-            }
-        }
-    }
-}
-// A ChainNode watches a single key on an object. If you provide a starting
-// value for the key then the node won't actually watch it. For a root node
-// pass null for parent and key and object for value.
-class ChainNode {
-    constructor(parent, key, value) {
-        this.paths = undefined;
-        this.isWatching = false;
-        this.chains = undefined;
-        this.object = undefined;
-        this.count = 0;
-        this.parent = parent;
-        this.key = key;
-        this.content = value;
-        // It is false for the root of a chain (because we have no parent)
-        let isWatching = (this.isWatching = parent !== null);
-        if (isWatching) {
-            let parentValue = parent.value();
-            if (isObject(parentValue)) {
-                this.object = parentValue;
-                addChainWatcher(parentValue, key, this);
-            }
-        }
-    }
-    value() {
-        if (this.content === undefined && this.isWatching) {
-            let obj = this.parent.value();
-            this.content = lazyGet(obj, this.key);
-        }
-        return this.content;
-    }
-    destroy() {
-        // check if root
-        if (this.parent === null) {
-            destroyRoot(this);
-        }
-        else {
-            destroyOne(this);
-        }
-    }
-    // copies a top level object only
-    copyTo(target) {
-        let paths = this.paths;
-        if (paths !== undefined) {
-            let path;
-            for (path in paths) {
-                if (paths[path] > 0) {
-                    target.add(path);
-                }
-            }
-        }
-    }
-    // called on the root node of a chain to setup watchers on the specified
-    // path.
-    add(path) {
-        let paths = this.paths || (this.paths = {});
-        paths[path] = (paths[path] || 0) + 1;
-        let tails = path.split('.');
-        this.chain(tails.shift(), tails);
-    }
-    // called on the root node of a chain to teardown watcher on the specified
-    // path
-    remove(path) {
-        let paths = this.paths;
-        if (paths === undefined) {
-            return;
-        }
-        if (paths[path] > 0) {
-            paths[path]--;
-        }
-        let tails = path.split('.');
-        this.unchain(tails.shift(), tails);
-    }
-    chain(key, tails) {
-        let chains = this.chains;
-        if (chains === undefined) {
-            chains = this.chains = Object.create(null);
-        }
-        let node = chains[key];
-        if (node === undefined) {
-            node = chains[key] = new ChainNode(this, key, undefined);
-        }
-        node.count++; // count chains...
-        // chain rest of path if there is one
-        if (tails.length > 0) {
-            node.chain(tails.shift(), tails);
-        }
-    }
-    unchain(key, tails) {
-        let chains = this.chains;
-        let node = chains[key];
-        // unchain rest of path first...
-        if (tails.length > 0) {
-            node.unchain(tails.shift(), tails);
-        }
-        // delete node if needed.
-        node.count--;
-        if (node.count <= 0) {
-            chains[node.key] = undefined;
-            node.destroy();
-        }
-    }
-    notify(revalidate, affected) {
-        if (revalidate && this.isWatching) {
-            let parentValue = this.parent.value();
-            if (parentValue !== this.object) {
-                removeChainWatcher(this.object, this.key, this);
-                if (isObject(parentValue)) {
-                    this.object = parentValue;
-                    addChainWatcher(parentValue, this.key, this);
-                }
-                else {
-                    this.object = undefined;
-                }
-            }
-            this.content = undefined;
-        }
-        // then notify chains...
-        let chains = this.chains;
-        if (chains !== undefined) {
-            let node;
-            for (let key in chains) {
-                node = chains[key];
-                if (node !== undefined) {
-                    node.notify(revalidate, affected);
-                }
-            }
-        }
-        if (affected !== undefined && this.parent !== null) {
-            this.parent.populateAffected(this.key, 1, affected);
-        }
-    }
-    populateAffected(path, depth, affected) {
-        if (this.key) {
-            path = `${this.key}.${path}`;
-        }
-        if (this.parent !== null) {
-            this.parent.populateAffected(path, depth + 1, affected);
-        }
-        else if (depth > 1) {
-            affected.push(this.value(), path);
-        }
-    }
-}
-function lazyGet(obj, key) {
-    if (!isObject(obj)) {
-        return;
-    }
-    let meta = peekMeta(obj);
-    // check if object meant only to be a prototype
-    if (meta !== undefined && meta.proto === obj) {
-        return;
-    }
-    // Use `get` if the return value is an EachProxy or an uncacheable value.
-    if (key === '@each') {
-        return eachProxyFor(obj);
-    }
-    else if (isVolatile(obj, key, meta)) {
-        return get(obj, key);
-        // Otherwise attempt to get the cached value of the computed property
-    }
-    else {
-        return getCachedValueFor(obj, key);
-    }
-}
-function finishChains(meta) {
-    // finish any current chains node watchers that reference obj
-    let chainWatchers = meta.readableChainWatchers();
-    if (chainWatchers !== undefined) {
-        chainWatchers.revalidateAll();
-    }
-    // ensure that if we have inherited any chains they have been
-    // copied onto our own meta.
-    if (meta.readableChains() !== undefined) {
-        meta.writableChains(makeChainNode);
-    }
-}
-export { finishChains, makeChainNode, removeChainWatcher, ChainNode };