discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,166 +0,0 @@
-import { context } from 'ember-environment';
-import { getName, setName } from 'ember-utils';
-// TODO, this only depends on context, otherwise it could be in utils
-// move into its own package
-// it is needed by Mixin for classToString
-// maybe move it into environment
-const hasOwnProperty = Object.prototype.hasOwnProperty;
-let searchDisabled = false;
-const flags = {
-    _set: 0,
-    _unprocessedNamespaces: false,
-    get unprocessedNamespaces() {
-        return this._unprocessedNamespaces;
-    },
-    set unprocessedNamespaces(v) {
-        this._set++;
-        this._unprocessedNamespaces = v;
-    },
-};
-let unprocessedMixins = false;
-export const NAMESPACES = [];
-export const NAMESPACES_BY_ID = Object.create(null);
-export function addNamespace(namespace) {
-    flags.unprocessedNamespaces = true;
-    NAMESPACES.push(namespace);
-}
-export function removeNamespace(namespace) {
-    let name = getName(namespace);
-    delete NAMESPACES_BY_ID[name];
-    NAMESPACES.splice(NAMESPACES.indexOf(namespace), 1);
-    if (name in context.lookup && namespace === context.lookup[name]) {
-        context.lookup[name] = undefined;
-    }
-}
-export function findNamespaces() {
-    if (!flags.unprocessedNamespaces) {
-        return;
-    }
-    let lookup = context.lookup;
-    let keys = Object.keys(lookup);
-    for (let i = 0; i < keys.length; i++) {
-        let key = keys[i];
-        // Only process entities that start with uppercase A-Z
-        if (!isUppercase(key.charCodeAt(0))) {
-            continue;
-        }
-        let obj = tryIsNamespace(lookup, key);
-        if (obj) {
-            setName(obj, key);
-        }
-    }
-}
-export function findNamespace(name) {
-    if (!searchDisabled) {
-        processAllNamespaces();
-    }
-    return NAMESPACES_BY_ID[name];
-}
-export function processNamespace(namespace) {
-    _processNamespace([namespace.toString()], namespace, new Set());
-}
-export function processAllNamespaces() {
-    let unprocessedNamespaces = flags.unprocessedNamespaces;
-    if (unprocessedNamespaces) {
-        findNamespaces();
-        flags.unprocessedNamespaces = false;
-    }
-    if (unprocessedNamespaces || unprocessedMixins) {
-        let namespaces = NAMESPACES;
-        for (let i = 0; i < namespaces.length; i++) {
-            processNamespace(namespaces[i]);
-        }
-        unprocessedMixins = false;
-    }
-}
-export function classToString() {
-    let name = getName(this);
-    if (name !== void 0) {
-        return name;
-    }
-    name = calculateToString(this);
-    setName(this, name);
-    return name;
-}
-export function isSearchDisabled() {
-    return searchDisabled;
-}
-export function setSearchDisabled(flag) {
-    searchDisabled = !!flag;
-}
-export function setUnprocessedMixins() {
-    unprocessedMixins = true;
-}
-function _processNamespace(paths, root, seen) {
-    let idx = paths.length;
-    let id = paths.join('.');
-    NAMESPACES_BY_ID[id] = root;
-    setName(root, id);
-    // Loop over all of the keys in the namespace, looking for classes
-    for (let key in root) {
-        if (!hasOwnProperty.call(root, key)) {
-            continue;
-        }
-        let obj = root[key];
-        // If we are processing the `Ember` namespace, for example, the
-        // `paths` will start with `["Ember"]`. Every iteration through
-        // the loop will update the **second** element of this list with
-        // the key, so processing `Ember.View` will make the Array
-        // `['Ember', 'View']`.
-        paths[idx] = key;
-        // If we have found an unprocessed class
-        if (obj && obj.toString === classToString && getName(obj) === void 0) {
-            // Replace the class' `toString` with the dot-separated path
-            setName(obj, paths.join('.'));
-            // Support nested namespaces
-        }
-        else if (obj && obj.isNamespace) {
-            // Skip aliased namespaces
-            if (seen.has(obj)) {
-                continue;
-            }
-            seen.add(obj);
-            // Process the child namespace
-            _processNamespace(paths, obj, seen);
-        }
-    }
-    paths.length = idx; // cut out last item
-}
-function isUppercase(code) {
-    return (code >= 65 && code <= 90 // A
-    ); // Z
-}
-function tryIsNamespace(lookup, prop) {
-    try {
-        let obj = lookup[prop];
-        return (((obj !== null && typeof obj === 'object') || typeof obj === 'function') &&
-            obj.isNamespace &&
-            obj);
-    }
-    catch (e) {
-        // continue
-    }
-}
-function calculateToString(target) {
-    let str;
-    if (!searchDisabled) {
-        processAllNamespaces();
-        str = getName(target);
-        if (str !== void 0) {
-            return str;
-        }
-        let superclass = target;
-        do {
-            superclass = Object.getPrototypeOf(superclass);
-            if (superclass === Function.prototype || superclass === Object.prototype) {
-                break;
-            }
-            str = getName(target);
-            if (str !== void 0) {
-                str = `(subclass of ${str})`;
-                break;
-            }
-        } while (str === void 0);
-    }
-    return str || '(unknown)';
-}

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

@@ -1,34 +0,0 @@
-import changeEvent from './change_event';
-import { addListener, removeListener } from './events';
-import { unwatch, watch } from './watching';
-/**
-@module @ember/object
-*/
-/**
-  @method addObserver
-  @static
-  @for @ember/object/observers
-  @param obj
-  @param {String} path
-  @param {Object|Function} target
-  @param {Function|String} [method]
-  @public
-*/
-export function addObserver(obj, path, target, method) {
-    addListener(obj, changeEvent(path), target, method);
-    watch(obj, path);
-}
-/**
-  @method removeObserver
-  @static
-  @for @ember/object/observers
-  @param obj
-  @param {String} path
-  @param {Object|Function} target
-  @param {Function|String} [method]
-  @public
-*/
-export function removeObserver(obj, path, target, method) {
-    unwatch(obj, path);
-    removeListener(obj, changeEvent(path), target, method);
-}

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

@@ -1,48 +0,0 @@
-import { sendEvent } from './events';
-/**
-  ObserverSet is a data structure used to keep track of observers
-  that have been deferred.
-
-  It ensures that observers are called in the same order that they
-  were initially triggered.
-
-  It also ensures that observers for any object-key pairs are called
-  only once, even if they were triggered multiple times while
-  deferred. In this case, the order that the observer is called in
-  will depend on the first time the observer was triggered.
-
-  @private
-  @class ObserverSet
-*/
-export default class ObserverSet {
-    constructor() {
-        this.added = new Map();
-        this.queue = [];
-    }
-    add(object, key, event) {
-        let keys = this.added.get(object);
-        if (keys === undefined) {
-            keys = new Set();
-            this.added.set(object, keys);
-        }
-        if (!keys.has(key)) {
-            this.queue.push(object, key, event);
-            keys.add(key);
-        }
-    }
-    flush() {
-        // The queue is saved off to support nested flushes.
-        let queue = this.queue;
-        this.added.clear();
-        this.queue = [];
-        for (let i = 0; i < queue.length; i += 3) {
-            let object = queue[i];
-            let key = queue[i + 1];
-            let event = queue[i + 2];
-            if (object.isDestroying || object.isDestroyed) {
-                continue;
-            }
-            sendEvent(object, event, [object, key]);
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-import { Cache } from 'ember-utils';
-const firstDotIndexCache = new Cache(1000, key => key.indexOf('.'));
-export function isPath(path) {
-    return typeof path === 'string' && firstDotIndexCache.get(path) !== -1;
-}

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

@@ -1,192 +0,0 @@
-/**
-@module @ember/object
-*/
-import { assert } from '@ember/debug';
-import { DEBUG } from '@glimmer/env';
-import { descriptorFor, meta as metaFor, peekMeta, UNDEFINED } from 'ember-meta';
-import { overrideChains } from './property_events';
-// ..........................................................
-// DESCRIPTOR
-//
-/**
-  Objects of this type can implement an interface to respond to requests to
-  get and set. The default implementation handles simple properties.
-
-  @class Descriptor
-  @private
-*/
-export class Descriptor {
-    constructor() {
-        this.isDescriptor = true;
-        this.enumerable = true;
-    }
-    setup(_obj, _keyName) { }
-    teardown(_obj, _keyName, _meta) { }
-}
-// ..........................................................
-// DEFINING PROPERTIES API
-//
-export function MANDATORY_SETTER_FUNCTION(name) {
-    function SETTER_FUNCTION(value) {
-        let m = peekMeta(this);
-        if (!m.isInitialized(this)) {
-            m.writeValues(name, value);
-        }
-        else {
-            assert(`You must use set() to set the \`${name}\` property (of ${this}) to \`${value}\`.`, false);
-        }
-    }
-    return Object.assign(SETTER_FUNCTION, { isMandatorySetter: true });
-}
-export function DEFAULT_GETTER_FUNCTION(name) {
-    return function GETTER_FUNCTION() {
-        let meta = peekMeta(this);
-        if (meta !== undefined) {
-            return meta.peekValues(name);
-        }
-    };
-}
-export function INHERITING_GETTER_FUNCTION(name) {
-    function IGETTER_FUNCTION() {
-        let meta = peekMeta(this);
-        let val;
-        if (meta !== undefined) {
-            val = meta.readInheritedValue('values', name);
-        }
-        if (val === UNDEFINED) {
-            let proto = Object.getPrototypeOf(this);
-            return proto && proto[name];
-        }
-        else {
-            return val;
-        }
-    }
-    return Object.assign(IGETTER_FUNCTION, {
-        isInheritingGetter: true,
-    });
-}
-function DESCRIPTOR_GETTER_FUNCTION(name, descriptor) {
-    return function CPGETTER_FUNCTION() {
-        return descriptor.get(this, name);
-    };
-}
-/**
-  NOTE: This is a low-level method used by other parts of the API. You almost
-  never want to call this method directly. Instead you should use
-  `mixin()` to define new properties.
-
-  Defines a property on an object. This method works much like the ES5
-  `Object.defineProperty()` method except that it can also accept computed
-  properties and other special descriptors.
-
-  Normally this method takes only three parameters. However if you pass an
-  instance of `Descriptor` as the third param then you can pass an
-  optional value as the fourth parameter. This is often more efficient than
-  creating new descriptor hashes for each property.
-
-  ## Examples
-
-  ```javascript
-  import { defineProperty, computed } from '@ember/object';
-
-  // ES5 compatible mode
-  defineProperty(contact, 'firstName', {
-    writable: true,
-    configurable: false,
-    enumerable: true,
-    value: 'Charles'
-  });
-
-  // define a simple property
-  defineProperty(contact, 'lastName', undefined, 'Jolley');
-
-  // define a computed property
-  defineProperty(contact, 'fullName', computed('firstName', 'lastName', function() {
-    return this.firstName+' '+this.lastName;
-  }));
-  ```
-
-  @public
-  @method defineProperty
-  @static
-  @for @ember/object
-  @param {Object} obj the object to define this property on. This may be a prototype.
-  @param {String} keyName the name of the property
-  @param {Descriptor} [desc] an instance of `Descriptor` (typically a
-    computed property) or an ES5 descriptor.
-    You must provide this or `data` but not both.
-  @param {*} [data] something other than a descriptor, that will
-    become the explicit value of this property.
-*/
-export function defineProperty(obj, keyName, desc, data, meta) {
-    if (meta === undefined) {
-        meta = metaFor(obj);
-    }
-    let watching = meta.peekWatching(keyName) > 0;
-    let previousDesc = descriptorFor(obj, keyName, meta);
-    let wasDescriptor = previousDesc !== undefined;
-    if (wasDescriptor) {
-        previousDesc.teardown(obj, keyName, meta);
-        meta.removeDescriptors(keyName);
-    }
-    // used to track if the the property being defined be enumerable
-    let enumerable = true;
-    // Ember.NativeArray is a normal Ember.Mixin that we mix into `Array.prototype` when prototype extensions are enabled
-    // mutating a native object prototype like this should _not_ result in enumerable properties being added (or we have significant
-    // issues with things like deep equality checks from test frameworks, or things like jQuery.extend(true, [], [])).
-    //
-    // this is a hack, and we should stop mutating the array prototype by default 😫
-    if (obj === Array.prototype) {
-        enumerable = false;
-    }
-    let value;
-    if (desc instanceof Descriptor) {
-        value = desc;
-        Object.defineProperty(obj, keyName, {
-            configurable: true,
-            enumerable,
-            get: DESCRIPTOR_GETTER_FUNCTION(keyName, value),
-        });
-        meta.writeDescriptors(keyName, value);
-        desc.setup(obj, keyName);
-    }
-    else if (desc === undefined || desc === null) {
-        value = data;
-        if (DEBUG && watching) {
-            meta.writeValues(keyName, data);
-            let defaultDescriptor = {
-                configurable: true,
-                enumerable,
-                set: MANDATORY_SETTER_FUNCTION(keyName),
-                get: DEFAULT_GETTER_FUNCTION(keyName),
-            };
-            Object.defineProperty(obj, keyName, defaultDescriptor);
-        }
-        else if (wasDescriptor || enumerable === false) {
-            Object.defineProperty(obj, keyName, {
-                configurable: true,
-                enumerable,
-                writable: true,
-                value,
-            });
-        }
-        else {
-            obj[keyName] = data;
-        }
-    }
-    else {
-        value = desc;
-        // fallback to ES5
-        Object.defineProperty(obj, keyName, desc);
-    }
-    // if key is being watched, override chains that
-    // were initialized with the prototype
-    if (watching) {
-        overrideChains(obj, keyName, meta);
-    }
-    // The `value` passed to the `didDefineProperty` hook is
-    // either the descriptor or data, whichever was passed.
-    if (typeof obj.didDefineProperty === 'function') {
-        obj.didDefineProperty(obj, keyName, value);
-    }
-}