discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-glimmer/lib/syntax/utils.js

@@ -1,6 +0,0 @@
-export function hashToArgs(hash) {
-    if (hash === null)
-        return null;
-    let names = hash[0].map(key => `@${key}`);
-    return [names, hash[1]];
-}

data/dist/es/ember-glimmer/lib/template-compiler.js

@@ -1,7 +0,0 @@
-import RuntimeResolver from './resolver';
-// factory for DI
-export default {
-    create() {
-        return new RuntimeResolver().compiler;
-    },
-};

data/dist/es/ember-glimmer/lib/template.js

@@ -1,16 +0,0 @@
-import { templateFactory } from '@glimmer/opcode-compiler';
-import { getOwner } from 'ember-owner';
-export default function template(json) {
-    return new FactoryWrapper(templateFactory(json));
-}
-class FactoryWrapper {
-    constructor(factory) {
-        this.factory = factory;
-        this.id = factory.id;
-        this.meta = factory.meta;
-    }
-    create(injections) {
-        const owner = getOwner(injections);
-        return this.factory.create(injections.compiler, { owner });
-    }
-}

data/dist/es/ember-glimmer/lib/template_registry.js

@@ -1,18 +0,0 @@
-let TEMPLATES = {};
-export function setTemplates(templates) {
-    TEMPLATES = templates;
-}
-export function getTemplates() {
-    return TEMPLATES;
-}
-export function getTemplate(name) {
-    if (TEMPLATES.hasOwnProperty(name)) {
-        return TEMPLATES[name];
-    }
-}
-export function hasTemplate(name) {
-    return TEMPLATES.hasOwnProperty(name);
-}
-export function setTemplate(name, template) {
-    return (TEMPLATES[name] = template);
-}

data/dist/es/ember-glimmer/lib/templates/component.js

@@ -1,2 +0,0 @@
-import template from '../template';
-export default template({"id":"9QlMnd4c","block":"{\"symbols\":[\"&default\"],\"statements\":[[14,1]],\"hasEval\":false}","meta":{"moduleName":"packages/ember-glimmer/lib/templates/component.hbs"}});

data/dist/es/ember-glimmer/lib/templates/empty.js

@@ -1,2 +0,0 @@
-import template from '../template';
-export default template({"id":"5jp2oO+o","block":"{\"symbols\":[],\"statements\":[],\"hasEval\":false}","meta":{"moduleName":"packages/ember-glimmer/lib/templates/empty.hbs"}});

data/dist/es/ember-glimmer/lib/templates/link-to.js

@@ -1,2 +0,0 @@
-import template from '../template';
-export default template({"id":"/tT8MjC4","block":"{\"symbols\":[\"&default\"],\"statements\":[[4,\"if\",[[23,[\"linkTitle\"]]],null,{\"statements\":[[1,[21,\"linkTitle\"],false]],\"parameters\":[]},{\"statements\":[[14,1]],\"parameters\":[]}]],\"hasEval\":false}","meta":{"moduleName":"packages/ember-glimmer/lib/templates/link-to.hbs"}});

data/dist/es/ember-glimmer/lib/templates/outlet.js

@@ -1,2 +0,0 @@
-import template from '../template';
-export default template({"id":"qAsZ1L5U","block":"{\"symbols\":[],\"statements\":[[1,[21,\"outlet\"],false]],\"hasEval\":false}","meta":{"moduleName":"packages/ember-glimmer/lib/templates/outlet.hbs"}});

data/dist/es/ember-glimmer/lib/templates/root.js

@@ -1,2 +0,0 @@
-import template from '../template';
-export default template({"id":"Zi0CBVtc","block":"{\"symbols\":[],\"statements\":[[1,[27,\"component\",[[22,0,[]]],null],false]],\"hasEval\":false}","meta":{"moduleName":"packages/ember-glimmer/lib/templates/root.hbs"}});

data/dist/es/ember-glimmer/lib/utils/bindings.js

@@ -1,180 +0,0 @@
-import { assert } from '@ember/debug';
-import { dasherize } from '@ember/string';
-import { CachedReference, combine, map } from '@glimmer/reference';
-import { PrimitiveReference } from '@glimmer/runtime';
-import { Ops } from '@glimmer/wire-format';
-import { get } from 'ember-metal';
-import { ROOT_REF } from '../component';
-import { referenceFromParts } from './references';
-import { htmlSafe, isHTMLSafe } from './string';
-export function referenceForKey(component, key) {
-    return component[ROOT_REF].get(key);
-}
-function referenceForParts(component, parts) {
-    let isAttrs = parts[0] === 'attrs';
-    // TODO deprecate this
-    if (isAttrs) {
-        parts.shift();
-        if (parts.length === 1) {
-            return referenceForKey(component, parts[0]);
-        }
-    }
-    return referenceFromParts(component[ROOT_REF], parts);
-}
-// TODO we should probably do this transform at build time
-export function wrapComponentClassAttribute(hash) {
-    if (hash === null) {
-        return;
-    }
-    let [keys, values] = hash;
-    let index = keys === null ? -1 : keys.indexOf('class');
-    if (index !== -1) {
-        let value = values[index];
-        if (!Array.isArray(value)) {
-            return;
-        }
-        let [type] = value;
-        if (type === Ops.Get || type === Ops.MaybeLocal) {
-            let path = value[value.length - 1];
-            let propName = path[path.length - 1];
-            values[index] = [Ops.Helper, '-class', [value, propName], null];
-        }
-    }
-}
-export const AttributeBinding = {
-    parse(microsyntax) {
-        let colonIndex = microsyntax.indexOf(':');
-        if (colonIndex === -1) {
-            assert('You cannot use class as an attributeBinding, use classNameBindings instead.', microsyntax !== 'class');
-            return [microsyntax, microsyntax, true];
-        }
-        else {
-            let prop = microsyntax.substring(0, colonIndex);
-            let attribute = microsyntax.substring(colonIndex + 1);
-            assert('You cannot use class as an attributeBinding, use classNameBindings instead.', attribute !== 'class');
-            return [prop, attribute, false];
-        }
-    },
-    install(_element, component, parsed, operations) {
-        let [prop, attribute, isSimple] = parsed;
-        if (attribute === 'id') {
-            let elementId = get(component, prop);
-            if (elementId === undefined || elementId === null) {
-                elementId = component.elementId;
-            }
-            elementId = PrimitiveReference.create(elementId);
-            operations.setAttribute('id', elementId, true, null);
-            // operations.addStaticAttribute(element, 'id', elementId);
-            return;
-        }
-        let isPath = prop.indexOf('.') > -1;
-        let reference = isPath
-            ? referenceForParts(component, prop.split('.'))
-            : referenceForKey(component, prop);
-        assert(`Illegal attributeBinding: '${prop}' is not a valid attribute name.`, !(isSimple && isPath));
-        if (attribute === 'style') {
-            reference = new StyleBindingReference(reference, referenceForKey(component, 'isVisible'));
-        }
-        operations.setAttribute(attribute, reference, false, null);
-        // operations.addDynamicAttribute(element, attribute, reference, false);
-    },
-};
-const DISPLAY_NONE = 'display: none;';
-const SAFE_DISPLAY_NONE = htmlSafe(DISPLAY_NONE);
-class StyleBindingReference extends CachedReference {
-    constructor(inner, isVisible) {
-        super();
-        this.inner = inner;
-        this.isVisible = isVisible;
-        this.tag = combine([inner.tag, isVisible.tag]);
-    }
-    compute() {
-        let value = this.inner.value();
-        let isVisible = this.isVisible.value();
-        if (isVisible !== false) {
-            return value;
-        }
-        else if (!value) {
-            return SAFE_DISPLAY_NONE;
-        }
-        else {
-            let style = value + ' ' + DISPLAY_NONE;
-            return isHTMLSafe(value) ? htmlSafe(style) : style;
-        }
-    }
-}
-export const IsVisibleBinding = {
-    install(_element, component, operations) {
-        operations.setAttribute('style', map(referenceForKey(component, 'isVisible'), this.mapStyleValue), false, null);
-        // // the upstream type for addDynamicAttribute's `value` argument
-        // // appears to be incorrect. It is currently a Reference<string>, I
-        // // think it should be a Reference<string|null>.
-        // operations.addDynamicAttribute(element, 'style', ref as any as Reference<string>, false);
-    },
-    mapStyleValue(isVisible) {
-        return isVisible === false ? SAFE_DISPLAY_NONE : null;
-    },
-};
-export const ClassNameBinding = {
-    install(_element, component, microsyntax, operations) {
-        let [prop, truthy, falsy] = microsyntax.split(':');
-        let isStatic = prop === '';
-        if (isStatic) {
-            operations.setAttribute('class', PrimitiveReference.create(truthy), true, null);
-        }
-        else {
-            let isPath = prop.indexOf('.') > -1;
-            let parts = isPath ? prop.split('.') : [];
-            let value = isPath ? referenceForParts(component, parts) : referenceForKey(component, prop);
-            let ref;
-            if (truthy === undefined) {
-                ref = new SimpleClassNameBindingReference(value, isPath ? parts[parts.length - 1] : prop);
-            }
-            else {
-                ref = new ColonClassNameBindingReference(value, truthy, falsy);
-            }
-            operations.setAttribute('class', ref, false, null);
-            // // the upstream type for addDynamicAttribute's `value` argument
-            // // appears to be incorrect. It is currently a Reference<string>, I
-            // // think it should be a Reference<string|null>.
-            // operations.addDynamicAttribute(element, 'class', ref as any as Reference<string>, false);
-        }
-    },
-};
-export class SimpleClassNameBindingReference extends CachedReference {
-    constructor(inner, path) {
-        super();
-        this.inner = inner;
-        this.path = path;
-        this.tag = inner.tag;
-        this.inner = inner;
-        this.path = path;
-        this.dasherizedPath = null;
-    }
-    compute() {
-        let value = this.inner.value();
-        if (value === true) {
-            let { path, dasherizedPath } = this;
-            return dasherizedPath || (this.dasherizedPath = dasherize(path));
-        }
-        else if (value || value === 0) {
-            return String(value);
-        }
-        else {
-            return null;
-        }
-    }
-}
-class ColonClassNameBindingReference extends CachedReference {
-    constructor(inner, truthy = null, falsy = null) {
-        super();
-        this.inner = inner;
-        this.truthy = truthy;
-        this.falsy = falsy;
-        this.tag = inner.tag;
-    }
-    compute() {
-        let { inner, truthy, falsy } = this;
-        return inner.value() ? truthy : falsy;
-    }
-}

data/dist/es/ember-glimmer/lib/utils/curly-component-state-bucket.js

@@ -1,36 +0,0 @@
-// tslint:disable-next-line:no-empty
-function NOOP() { }
-/**
-  @module ember
-*/
-/**
-  Represents the internal state of the component.
-
-  @class ComponentStateBucket
-  @private
-*/
-export default class ComponentStateBucket {
-    constructor(environment, component, args, finalizer, hasWrappedElement) {
-        this.environment = environment;
-        this.component = component;
-        this.args = args;
-        this.finalizer = finalizer;
-        this.hasWrappedElement = hasWrappedElement;
-        this.classRef = null;
-        this.classRef = null;
-        this.argsRevision = args === null ? 0 : args.tag.value();
-    }
-    destroy() {
-        let { component, environment } = this;
-        if (environment.isInteractive) {
-            component.trigger('willDestroyElement');
-            component.trigger('willClearRender');
-        }
-        environment.destroyedComponents.push(component);
-    }
-    finalize() {
-        let { finalizer } = this;
-        finalizer();
-        this.finalizer = NOOP;
-    }
-}

data/dist/es/ember-glimmer/lib/utils/custom-component-manager.js

@@ -1,20 +0,0 @@
-import { GLIMMER_CUSTOM_COMPONENT_MANAGER } from '@ember/canary-features';
-const getPrototypeOf = Object.getPrototypeOf;
-const MANAGERS = new WeakMap();
-export function setComponentManager(managerId, obj) {
-    MANAGERS.set(obj, managerId);
-    return obj;
-}
-export function getComponentManager(obj) {
-    if (!GLIMMER_CUSTOM_COMPONENT_MANAGER) {
-        return;
-    }
-    let pointer = obj;
-    while (pointer !== undefined && pointer !== null) {
-        if (MANAGERS.has(pointer)) {
-            return MANAGERS.get(pointer);
-        }
-        pointer = getPrototypeOf(pointer);
-    }
-    return;
-}

data/dist/es/ember-glimmer/lib/utils/debug-stack.js

@@ -1,57 +0,0 @@
-// @ts-check
-import { DEBUG } from '@glimmer/env';
-let DebugStack;
-if (DEBUG) {
-    class Element {
-        constructor(name) {
-            this.name = name;
-        }
-    }
-    class TemplateElement extends Element {
-    }
-    class EngineElement extends Element {
-    }
-    // tslint:disable-next-line:no-shadowed-variable
-    DebugStack = class DebugStack {
-        constructor() {
-            this._stack = [];
-        }
-        push(name) {
-            this._stack.push(new TemplateElement(name));
-        }
-        pushEngine(name) {
-            this._stack.push(new EngineElement(name));
-        }
-        pop() {
-            let element = this._stack.pop();
-            if (element) {
-                return element.name;
-            }
-        }
-        peek() {
-            let template = this._currentTemplate();
-            let engine = this._currentEngine();
-            if (engine) {
-                return `"${template}" (in "${engine}")`;
-            }
-            else if (template) {
-                return `"${template}"`;
-            }
-        }
-        _currentTemplate() {
-            return this._getCurrentByType(TemplateElement);
-        }
-        _currentEngine() {
-            return this._getCurrentByType(EngineElement);
-        }
-        _getCurrentByType(type) {
-            for (let i = this._stack.length; i >= 0; i--) {
-                let element = this._stack[i];
-                if (element instanceof type) {
-                    return element.name;
-                }
-            }
-        }
-    };
-}
-export default DebugStack;

data/dist/es/ember-glimmer/lib/utils/iterable.js

@@ -1,358 +0,0 @@
-import { assert } from '@ember/debug';
-import { combine, CONSTANT_TAG, UpdatableTag, } from '@glimmer/reference';
-import { get, objectAt, tagFor, tagForProperty } from 'ember-metal';
-import { _contentFor, isEmberArray } from 'ember-runtime';
-import { guidFor, HAS_NATIVE_SYMBOL, isProxy } from 'ember-utils';
-import { isEachIn } from '../helpers/each-in';
-import { UpdatableReference } from './references';
-const ITERATOR_KEY_GUID = 'be277757-bbbe-4620-9fcb-213ef433cca2';
-export default function iterableFor(ref, keyPath) {
-    if (isEachIn(ref)) {
-        return new EachInIterable(ref, keyPath || '@key');
-    }
-    else {
-        return new EachIterable(ref, keyPath || '@identity');
-    }
-}
-class BoundedIterator {
-    constructor(length, keyFor) {
-        this.length = length;
-        this.keyFor = keyFor;
-        this.position = 0;
-    }
-    isEmpty() {
-        return false;
-    }
-    memoFor(position) {
-        return position;
-    }
-    next() {
-        let { length, keyFor, position } = this;
-        if (position >= length) {
-            return null;
-        }
-        let value = this.valueFor(position);
-        let memo = this.memoFor(position);
-        let key = keyFor(value, memo, position);
-        this.position++;
-        return { key, value, memo };
-    }
-}
-class ArrayIterator extends BoundedIterator {
-    constructor(array, length, keyFor) {
-        super(length, keyFor);
-        this.array = array;
-    }
-    static from(array, keyFor) {
-        let { length } = array;
-        if (length === 0) {
-            return EMPTY_ITERATOR;
-        }
-        else {
-            return new this(array, length, keyFor);
-        }
-    }
-    static fromForEachable(object, keyFor) {
-        let array = [];
-        object.forEach(item => array.push(item));
-        return this.from(array, keyFor);
-    }
-    valueFor(position) {
-        return this.array[position];
-    }
-}
-class EmberArrayIterator extends BoundedIterator {
-    constructor(array, length, keyFor) {
-        super(length, keyFor);
-        this.array = array;
-    }
-    static from(array, keyFor) {
-        let { length } = array;
-        if (length === 0) {
-            return EMPTY_ITERATOR;
-        }
-        else {
-            return new this(array, length, keyFor);
-        }
-    }
-    valueFor(position) {
-        return objectAt(this.array, position);
-    }
-}
-class ObjectIterator extends BoundedIterator {
-    constructor(keys, values, length, keyFor) {
-        super(length, keyFor);
-        this.keys = keys;
-        this.values = values;
-    }
-    static fromIndexable(obj, keyFor) {
-        let keys = Object.keys(obj);
-        let values = [];
-        let { length } = keys;
-        for (let i = 0; i < length; i++) {
-            values.push(get(obj, keys[i]));
-        }
-        if (length === 0) {
-            return EMPTY_ITERATOR;
-        }
-        else {
-            return new this(keys, values, length, keyFor);
-        }
-    }
-    static fromForEachable(obj, keyFor) {
-        let keys = [];
-        let values = [];
-        let length = 0;
-        let isMapLike = false;
-        obj.forEach((value, key) => {
-            isMapLike = isMapLike || arguments.length >= 2;
-            if (isMapLike) {
-                keys.push(key);
-            }
-            values.push(value);
-            length++;
-        });
-        if (length === 0) {
-            return EMPTY_ITERATOR;
-        }
-        else if (isMapLike) {
-            return new this(keys, values, length, keyFor);
-        }
-        else {
-            return new ArrayIterator(values, length, keyFor);
-        }
-    }
-    valueFor(position) {
-        return this.values[position];
-    }
-    memoFor(position) {
-        return this.keys[position];
-    }
-}
-class NativeIterator {
-    constructor(iterable, result, keyFor) {
-        this.iterable = iterable;
-        this.result = result;
-        this.keyFor = keyFor;
-        this.position = 0;
-    }
-    static from(iterable, keyFor) {
-        let iterator = iterable[Symbol.iterator]();
-        let result = iterator.next();
-        let { value, done } = result;
-        if (done) {
-            return EMPTY_ITERATOR;
-        }
-        else if (Array.isArray(value) && value.length === 2) {
-            return new this(iterator, result, keyFor);
-        }
-        else {
-            return new ArrayLikeNativeIterator(iterator, result, keyFor);
-        }
-    }
-    isEmpty() {
-        return false;
-    }
-    next() {
-        let { iterable, result, position, keyFor } = this;
-        if (result.done) {
-            return null;
-        }
-        let value = this.valueFor(result, position);
-        let memo = this.memoFor(result, position);
-        let key = keyFor(value, memo, position);
-        this.position++;
-        this.result = iterable.next();
-        return { key, value, memo };
-    }
-}
-class ArrayLikeNativeIterator extends NativeIterator {
-    valueFor(result) {
-        return result.value;
-    }
-    memoFor(_result, position) {
-        return position;
-    }
-}
-class MapLikeNativeIterator extends NativeIterator {
-    valueFor(result) {
-        return result.value[1];
-    }
-    memoFor(result) {
-        return result.value[0];
-    }
-}
-const EMPTY_ITERATOR = {
-    isEmpty() {
-        return true;
-    },
-    next() {
-        assert('Cannot call next() on an empty iterator');
-        return null;
-    },
-};
-class EachInIterable {
-    constructor(ref, keyPath) {
-        this.ref = ref;
-        this.keyPath = keyPath;
-        this.valueTag = UpdatableTag.create(CONSTANT_TAG);
-        this.tag = combine([ref.tag, this.valueTag]);
-    }
-    iterate() {
-        let { ref, valueTag } = this;
-        let iterable = ref.value();
-        let tag = tagFor(iterable);
-        if (isProxy(iterable)) {
-            // this is because the each-in doesn't actually get(proxy, 'key') but bypasses it
-            // and the proxy's tag is lazy updated on access
-            iterable = _contentFor(iterable);
-        }
-        valueTag.inner.update(tag);
-        if (!isIndexable(iterable)) {
-            return EMPTY_ITERATOR;
-        }
-        if (Array.isArray(iterable) || isEmberArray(iterable)) {
-            return ObjectIterator.fromIndexable(iterable, this.keyFor(true));
-        }
-        else if (HAS_NATIVE_SYMBOL && isNativeIterable(iterable)) {
-            return MapLikeNativeIterator.from(iterable, this.keyFor());
-        }
-        else if (hasForEach(iterable)) {
-            return ObjectIterator.fromForEachable(iterable, this.keyFor());
-        }
-        else {
-            return ObjectIterator.fromIndexable(iterable, this.keyFor(true));
-        }
-    }
-    valueReferenceFor(item) {
-        return new UpdatableReference(item.value);
-    }
-    updateValueReference(ref, item) {
-        ref.update(item.value);
-    }
-    memoReferenceFor(item) {
-        return new UpdatableReference(item.memo);
-    }
-    updateMemoReference(ref, item) {
-        ref.update(item.memo);
-    }
-    keyFor(hasUniqueKeys = false) {
-        let { keyPath } = this;
-        switch (keyPath) {
-            case '@key':
-                return hasUniqueKeys ? ObjectKey : Unique(MapKey);
-            case '@index':
-                return Index;
-            case '@identity':
-                return Unique(Identity);
-            default:
-                assert(`Invalid key: ${keyPath}`, keyPath[0] !== '@');
-                return Unique(KeyPath(keyPath));
-        }
-    }
-}
-class EachIterable {
-    constructor(ref, keyPath) {
-        this.ref = ref;
-        this.keyPath = keyPath;
-        this.valueTag = UpdatableTag.create(CONSTANT_TAG);
-        this.tag = combine([ref.tag, this.valueTag]);
-    }
-    iterate() {
-        let { ref, valueTag } = this;
-        let iterable = ref.value();
-        valueTag.inner.update(tagForProperty(iterable, '[]'));
-        if (iterable === null || typeof iterable !== 'object') {
-            return EMPTY_ITERATOR;
-        }
-        let keyFor = this.keyFor();
-        if (Array.isArray(iterable)) {
-            return ArrayIterator.from(iterable, keyFor);
-        }
-        else if (isEmberArray(iterable)) {
-            return EmberArrayIterator.from(iterable, keyFor);
-        }
-        else if (HAS_NATIVE_SYMBOL && isNativeIterable(iterable)) {
-            return ArrayLikeNativeIterator.from(iterable, keyFor);
-        }
-        else if (hasForEach(iterable)) {
-            return ArrayIterator.fromForEachable(iterable, keyFor);
-        }
-        else {
-            return EMPTY_ITERATOR;
-        }
-    }
-    valueReferenceFor(item) {
-        return new UpdatableReference(item.value);
-    }
-    updateValueReference(ref, item) {
-        ref.update(item.value);
-    }
-    memoReferenceFor(item) {
-        return new UpdatableReference(item.memo);
-    }
-    updateMemoReference(ref, item) {
-        ref.update(item.memo);
-    }
-    keyFor() {
-        let { keyPath } = this;
-        switch (keyPath) {
-            case '@index':
-                return Index;
-            case '@identity':
-                return Unique(Identity);
-            default:
-                assert(`Invalid key: ${keyPath}`, keyPath[0] !== '@');
-                return Unique(KeyPath(keyPath));
-        }
-    }
-}
-function hasForEach(value) {
-    return typeof value['forEach'] === 'function';
-}
-function isNativeIterable(value) {
-    return typeof value[Symbol.iterator] === 'function';
-}
-function isIndexable(value) {
-    return value !== null && (typeof value === 'object' || typeof value === 'function');
-}
-// Position in an array is guarenteed to be unique
-function Index(_value, _memo, position) {
-    return String(position);
-}
-// Object.keys(...) is guarenteed to be strings and unique
-function ObjectKey(_value, memo) {
-    return memo;
-}
-// Map keys can be any objects
-function MapKey(_value, memo) {
-    return Identity(memo);
-}
-function Identity(value) {
-    switch (typeof value) {
-        case 'string':
-            return value;
-        case 'number':
-            return String(value);
-        default:
-            return guidFor(value);
-    }
-}
-function KeyPath(keyPath) {
-    return (value) => String(get(value, keyPath));
-}
-function Unique(func) {
-    let seen = {};
-    return (value, memo, position) => {
-        let key = func(value, memo, position);
-        let count = seen[key];
-        if (count === undefined) {
-            seen[key] = 0;
-            return key;
-        }
-        else {
-            seen[key] = ++count;
-            return `${key}${ITERATOR_KEY_GUID}${count}`;
-        }
-    };
-}