discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,43 +0,0 @@
-import { changeProperties } from './property_events';
-import { set } from './property_set';
-/**
- @module @ember/object
-*/
-/**
-  Set a list of properties on an object. These properties are set inside
-  a single `beginPropertyChanges` and `endPropertyChanges` batch, so
-  observers will be buffered.
-
-  ```javascript
-  import EmberObject from '@ember/object';
-  let anObject = EmberObject.create();
-
-  anObject.setProperties({
-    firstName: 'Stanley',
-    lastName: 'Stuart',
-    age: 21
-  });
-  ```
-
-  @method setProperties
-  @static
-  @for @ember/object
-  @param obj
-  @param {Object} properties
-  @return properties
-  @public
-*/
-export default function setProperties(obj, properties) {
-    if (properties === null || typeof properties !== 'object') {
-        return properties;
-    }
-    changeProperties(() => {
-        let props = Object.keys(properties);
-        let propertyName;
-        for (let i = 0; i < props.length; i++) {
-            propertyName = props[i];
-            set(obj, propertyName, properties[propertyName]);
-        }
-    });
-    return properties;
-}

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

@@ -1,81 +0,0 @@
-import { EMBER_METAL_TRACKED_PROPERTIES } from '@ember/canary-features';
-import { backburner } from '@ember/runloop';
-import { combine, CONSTANT_TAG, DirtyableTag, UpdatableTag } from '@glimmer/reference';
-import { meta as metaFor } from 'ember-meta';
-import { isProxy } from 'ember-utils';
-let hasViews = () => false;
-export function setHasViews(fn) {
-    hasViews = fn;
-}
-function makeTag() {
-    return DirtyableTag.create();
-}
-export function tagForProperty(object, propertyKey, _meta) {
-    if (typeof object !== 'object' || object === null) {
-        return CONSTANT_TAG;
-    }
-    let meta = _meta === undefined ? metaFor(object) : _meta;
-    if (isProxy(object)) {
-        return tagFor(object, meta);
-    }
-    let tags = meta.writableTags();
-    let tag = tags[propertyKey];
-    if (tag) {
-        return tag;
-    }
-    if (EMBER_METAL_TRACKED_PROPERTIES) {
-        let pair = combine([makeTag(), UpdatableTag.create(CONSTANT_TAG)]);
-        return (tags[propertyKey] = pair);
-    }
-    else {
-        return (tags[propertyKey] = makeTag());
-    }
-}
-export function tagFor(object, _meta) {
-    if (typeof object === 'object' && object !== null) {
-        let meta = _meta === undefined ? metaFor(object) : _meta;
-        return meta.writableTag(makeTag);
-    }
-    else {
-        return CONSTANT_TAG;
-    }
-}
-export let dirty;
-export let update;
-if (EMBER_METAL_TRACKED_PROPERTIES) {
-    dirty = tag => {
-        tag.inner.first.inner.dirty();
-    };
-    update = (outer, inner) => {
-        outer.inner.second.inner.update(inner);
-    };
-}
-else {
-    dirty = tag => {
-        tag.inner.dirty();
-    };
-}
-export function markObjectAsDirty(obj, propertyKey, meta) {
-    let objectTag = meta.readableTag();
-    if (objectTag !== undefined) {
-        if (isProxy(obj)) {
-            objectTag.inner.first.inner.dirty();
-        }
-        else {
-            objectTag.inner.dirty();
-        }
-    }
-    let tags = meta.readableTags();
-    let propertyTag = tags !== undefined ? tags[propertyKey] : undefined;
-    if (propertyTag !== undefined) {
-        dirty(propertyTag);
-    }
-    if (objectTag !== undefined || propertyTag !== undefined) {
-        ensureRunloop();
-    }
-}
-function ensureRunloop() {
-    if (hasViews()) {
-        backburner.ensureInstance();
-    }
-}

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

@@ -1,201 +0,0 @@
-import { combine, CONSTANT_TAG } from '@glimmer/reference';
-import { dirty, tagFor, tagForProperty, update } from './tags';
-/**
-  An object that that tracks @tracked properties that were consumed.
-
-  @private
- */
-class Tracker {
-    constructor() {
-        this.tags = new Set();
-        this.last = null;
-    }
-    add(tag) {
-        this.tags.add(tag);
-        this.last = tag;
-    }
-    get size() {
-        return this.tags.size;
-    }
-    combine() {
-        if (this.tags.size === 0) {
-            return CONSTANT_TAG;
-        }
-        else if (this.tags.size === 1) {
-            return this.last;
-        }
-        else {
-            let tags = [];
-            this.tags.forEach(tag => tags.push(tag));
-            return combine(tags);
-        }
-    }
-}
-/**
-  @decorator
-  @private
-
-  Marks a property as tracked.
-
-  By default, a component's properties are expected to be static,
-  meaning you are not able to update them and have the template update accordingly.
-  Marking a property as tracked means that when that property changes,
-  a rerender of the component is scheduled so the template is kept up to date.
-
-  There are two usages for the `@tracked` decorator, shown below.
-
-  @example No dependencies
-
-  If you don't pass an argument to `@tracked`, only changes to that property
-  will be tracked:
-
-  ```typescript
-  import Component, { tracked } from '@glimmer/component';
-
-  export default class MyComponent extends Component {
-    @tracked
-    remainingApples = 10
-  }
-  ```
-
-  When something changes the component's `remainingApples` property, the rerender
-  will be scheduled.
-
-  @example Dependents
-
-  In the case that you have a computed property that depends other
-  properties, you want to track both so that when one of the
-  dependents change, a rerender is scheduled.
-
-  In the following example we have two properties,
-  `eatenApples`, and `remainingApples`.
-
-  ```typescript
-  import Component, { tracked } from '@glimmer/component';
-
-  const totalApples = 100;
-
-  export default class MyComponent extends Component {
-    @tracked
-    eatenApples = 0
-
-    @tracked('eatenApples')
-    get remainingApples() {
-      return totalApples - this.eatenApples;
-    }
-
-    increment() {
-      this.eatenApples = this.eatenApples + 1;
-    }
-  }
-  ```
-
-  @param dependencies Optional dependents to be tracked.
- */
-export function tracked(_target, key, descriptor) {
-    if ('value' in descriptor) {
-        return descriptorForDataProperty(key, descriptor);
-    }
-    else {
-        return descriptorForAccessor(key, descriptor);
-    }
-}
-/**
-  @private
-
-  Whenever a tracked computed property is entered, the current tracker is
-  saved off and a new tracker is replaced.
-
-  Any tracked properties consumed are added to the current tracker.
-
-  When a tracked computed property is exited, the tracker's tags are
-  combined and added to the parent tracker.
-
-  The consequence is that each tracked computed property has a tag
-  that corresponds to the tracked properties consumed inside of
-  itself, including child tracked computed properties.
- */
-let CURRENT_TRACKER = null;
-export function getCurrentTracker() {
-    return CURRENT_TRACKER;
-}
-export function setCurrentTracker(tracker = new Tracker()) {
-    return (CURRENT_TRACKER = tracker);
-}
-function descriptorForAccessor(key, descriptor) {
-    let get = descriptor.get;
-    let set = descriptor.set;
-    function getter() {
-        // Swap the parent tracker for a new tracker
-        let old = CURRENT_TRACKER;
-        let tracker = (CURRENT_TRACKER = new Tracker());
-        // Call the getter
-        let ret = get.call(this);
-        // Swap back the parent tracker
-        CURRENT_TRACKER = old;
-        // Combine the tags in the new tracker and add them to the parent tracker
-        let tag = tracker.combine();
-        if (CURRENT_TRACKER)
-            CURRENT_TRACKER.add(tag);
-        // Update the UpdatableTag for this property with the tag for all of the
-        // consumed dependencies.
-        update(tagForProperty(this, key), tag);
-        return ret;
-    }
-    function setter() {
-        dirty(tagForProperty(this, key));
-        set.apply(this, arguments);
-    }
-    return {
-        enumerable: true,
-        configurable: false,
-        get: get && getter,
-        set: set && setter,
-    };
-}
-/**
-  @private
-
-  A getter/setter for change tracking for a particular key. The accessor
-  acts just like a normal property, but it triggers the `propertyDidChange`
-  hook when written to.
-
-  Values are saved on the object using a "shadow key," or a symbol based on the
-  tracked property name. Sets write the value to the shadow key, and gets read
-  from it.
- */
-function descriptorForDataProperty(key, descriptor) {
-    let shadowKey = Symbol(key);
-    return {
-        enumerable: true,
-        configurable: true,
-        get() {
-            if (CURRENT_TRACKER)
-                CURRENT_TRACKER.add(tagForProperty(this, key));
-            if (!(shadowKey in this)) {
-                this[shadowKey] = descriptor.value;
-            }
-            return this[shadowKey];
-        },
-        set(newValue) {
-            tagFor(this).inner['dirty']();
-            dirty(tagForProperty(this, key));
-            this[shadowKey] = newValue;
-            propertyDidChange();
-        },
-    };
-}
-let propertyDidChange = function () { };
-export function setPropertyDidChange(cb) {
-    propertyDidChange = cb;
-}
-export class UntrackedPropertyError extends Error {
-    constructor(target, key, message) {
-        super(message);
-        this.target = target;
-        this.key = key;
-    }
-    static for(obj, key) {
-        return new UntrackedPropertyError(obj, key, `The property '${key}' on ${obj} was changed after being rendered. If you want to change a property used in a template after the component has rendered, mark the property as a tracked property with the @tracked decorator.`);
-    }
-}

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

@@ -1,137 +0,0 @@
-import { assert } from '@ember/debug';
-import { DEBUG } from '@glimmer/env';
-let runInTransaction;
-let didRender;
-let assertNotRendered;
-// detect-backtracking-rerender by default is debug build only
-if (DEBUG) {
-    // there are 2 states
-    // DEBUG
-    // tracks lastRef and lastRenderedIn per rendered object and key during a transaction
-    // release everything via normal weakmap semantics by just derefencing the weakmap
-    // RELEASE
-    // tracks transactionId per rendered object and key during a transaction
-    // release everything via normal weakmap semantics by just derefencing the weakmap
-    class TransactionRunner {
-        constructor() {
-            this.transactionId = 0;
-            this.inTransaction = false;
-            this.shouldReflush = false;
-            this.weakMap = new WeakMap();
-            if (DEBUG) {
-                // track templates
-                this.debugStack = undefined;
-            }
-        }
-        runInTransaction(context, methodName) {
-            this.before(context);
-            try {
-                context[methodName]();
-            }
-            finally {
-                this.after();
-            }
-            return this.shouldReflush;
-        }
-        didRender(object, key, reference) {
-            if (!this.inTransaction) {
-                return;
-            }
-            if (DEBUG) {
-                this.setKey(object, key, {
-                    lastRef: reference,
-                    lastRenderedIn: this.debugStack.peek(),
-                });
-            }
-            else {
-                this.setKey(object, key, this.transactionId);
-            }
-        }
-        assertNotRendered(object, key) {
-            if (!this.inTransaction) {
-                return;
-            }
-            if (this.hasRendered(object, key)) {
-                if (DEBUG) {
-                    let { lastRef, lastRenderedIn } = this.getKey(object, key);
-                    let currentlyIn = this.debugStack.peek();
-                    let parts = [];
-                    let label;
-                    if (lastRef !== undefined) {
-                        while (lastRef && lastRef._propertyKey) {
-                            parts.unshift(lastRef._propertyKey);
-                            lastRef = lastRef._parentReference;
-                        }
-                        label = parts.join('.');
-                    }
-                    else {
-                        label = 'the same value';
-                    }
-                    assert(`You modified "${label}" twice on ${object} in a single render. It was rendered in ${lastRenderedIn} and modified in ${currentlyIn}. This was unreliable and slow in Ember 1.x and is no longer supported. See https://github.com/emberjs/ember.js/issues/13948 for more details.`, false);
-                }
-                this.shouldReflush = true;
-            }
-        }
-        hasRendered(object, key) {
-            if (!this.inTransaction) {
-                return false;
-            }
-            if (DEBUG) {
-                return this.getKey(object, key) !== undefined;
-            }
-            return this.getKey(object, key) === this.transactionId;
-        }
-        before(context) {
-            this.inTransaction = true;
-            this.shouldReflush = false;
-            if (DEBUG) {
-                this.debugStack = context.env.debugStack;
-            }
-        }
-        after() {
-            this.transactionId++;
-            this.inTransaction = false;
-            if (DEBUG) {
-                this.debugStack = undefined;
-            }
-            this.clearObjectMap();
-        }
-        createMap(object) {
-            let map = Object.create(null);
-            this.weakMap.set(object, map);
-            return map;
-        }
-        getOrCreateMap(object) {
-            let map = this.weakMap.get(object);
-            if (map === undefined) {
-                map = this.createMap(object);
-            }
-            return map;
-        }
-        setKey(object, key, value) {
-            let map = this.getOrCreateMap(object);
-            map[key] = value;
-        }
-        getKey(object, key) {
-            let map = this.weakMap.get(object);
-            if (map !== undefined) {
-                return map[key];
-            }
-        }
-        clearObjectMap() {
-            this.weakMap = new WeakMap();
-        }
-    }
-    let runner = new TransactionRunner();
-    runInTransaction = runner.runInTransaction.bind(runner);
-    didRender = runner.didRender.bind(runner);
-    assertNotRendered = runner.assertNotRendered.bind(runner);
-}
-else {
-    // in production do nothing to detect reflushes
-    runInTransaction = (context, methodName) => {
-        context[methodName]();
-        return false;
-    };
-}
-export { runInTransaction as default, didRender, assertNotRendered };