discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,290 +0,0 @@
-import { EMBER_MODULE_UNIFICATION, GLIMMER_CUSTOM_COMPONENT_MANAGER } from '@ember/canary-features';
-import { assert } from '@ember/debug';
-import { RENDER_HELPER } from '@ember/deprecated-features';
-import { _instrumentStart } from '@ember/instrumentation';
-import { LazyCompiler, Macros, PartialDefinition } from '@glimmer/opcode-compiler';
-import { getDynamicVar } from '@glimmer/runtime';
-import { privatize as P } from 'container';
-import { ENV } from 'ember-environment';
-import { setOwner } from 'ember-owner';
-import { lookupComponent, lookupPartial } from 'ember-views';
-import CompileTimeLookup from './compile-time-lookup';
-import { CurlyComponentDefinition } from './component-managers/curly';
-import { CustomManagerDefinition } from './component-managers/custom';
-import { TemplateOnlyComponentDefinition } from './component-managers/template-only';
-import { isHelperFactory, isSimpleHelper } from './helper';
-import { default as classHelper } from './helpers/-class';
-import { default as htmlSafeHelper } from './helpers/-html-safe';
-import { default as inputTypeHelper } from './helpers/-input-type';
-import { default as normalizeClassHelper } from './helpers/-normalize-class';
-import { default as action } from './helpers/action';
-import { default as concat } from './helpers/concat';
-import { default as eachIn } from './helpers/each-in';
-import { default as get } from './helpers/get';
-import { default as hash } from './helpers/hash';
-import { inlineIf, inlineUnless } from './helpers/if-unless';
-import { default as log } from './helpers/log';
-import { default as mut } from './helpers/mut';
-import { default as queryParams } from './helpers/query-param';
-import { default as readonly } from './helpers/readonly';
-import { default as unbound } from './helpers/unbound';
-import ActionModifierManager from './modifiers/action';
-import { populateMacros } from './syntax';
-import { mountHelper } from './syntax/mount';
-import { outletHelper } from './syntax/outlet';
-import { renderHelper } from './syntax/render';
-import { getComponentManager } from './utils/custom-component-manager';
-import { ClassBasedHelperReference, SimpleHelperReference } from './utils/references';
-function instrumentationPayload(name) {
-    return { object: `component:${name}` };
-}
-function makeOptions(moduleName, namespace) {
-    return {
-        source: moduleName !== undefined ? `template:${moduleName}` : undefined,
-        namespace,
-    };
-}
-const BUILTINS_HELPERS = {
-    if: inlineIf,
-    action,
-    concat,
-    get,
-    hash,
-    log,
-    mut,
-    'query-params': queryParams,
-    readonly,
-    unbound,
-    unless: inlineUnless,
-    '-class': classHelper,
-    '-each-in': eachIn,
-    '-input-type': inputTypeHelper,
-    '-normalize-class': normalizeClassHelper,
-    '-html-safe': htmlSafeHelper,
-    '-get-dynamic-var': getDynamicVar,
-    '-mount': mountHelper,
-    '-outlet': outletHelper,
-};
-if (RENDER_HELPER) {
-    BUILTINS_HELPERS['-render'] = renderHelper;
-}
-const BUILTIN_MODIFIERS = {
-    action: new ActionModifierManager(),
-};
-export default class RuntimeResolver {
-    constructor() {
-        this.handles = [
-            undefined,
-        ];
-        this.objToHandle = new WeakMap();
-        this.builtInHelpers = BUILTINS_HELPERS;
-        this.builtInModifiers = BUILTIN_MODIFIERS;
-        // supports directly imported late bound layouts on component.prototype.layout
-        this.templateCache = new Map();
-        this.componentDefinitionCache = new Map();
-        this.customManagerCache = new Map();
-        this.templateCacheHits = 0;
-        this.templateCacheMisses = 0;
-        this.componentDefinitionCount = 0;
-        this.helperDefinitionCount = 0;
-        let macros = new Macros();
-        populateMacros(macros);
-        this.compiler = new LazyCompiler(new CompileTimeLookup(this), this, macros);
-    }
-    /***  IRuntimeResolver ***/
-    /**
-     * public componentDefHandleCount = 0;
-     * Called while executing Append Op.PushDynamicComponentManager if string
-     */
-    lookupComponentDefinition(name, meta) {
-        assert('You cannot use `textarea` as a component name.', name !== 'textarea');
-        assert('You cannot use `input` as a component name.', name !== 'input');
-        let handle = this.lookupComponentHandle(name, meta);
-        if (handle === null) {
-            assert(`Could not find component named "${name}" (no component or template with that name was found)`);
-            return null;
-        }
-        return this.resolve(handle);
-    }
-    lookupComponentHandle(name, meta) {
-        let nextHandle = this.handles.length;
-        let handle = this.handle(this._lookupComponentDefinition(name, meta));
-        if (nextHandle === handle) {
-            this.componentDefinitionCount++;
-        }
-        return handle;
-    }
-    /**
-     * Called by RuntimeConstants to lookup unresolved handles.
-     */
-    resolve(handle) {
-        return this.handles[handle];
-    }
-    // End IRuntimeResolver
-    /**
-     * Called by CompileTimeLookup compiling Unknown or Helper OpCode
-     */
-    lookupHelper(name, meta) {
-        let nextHandle = this.handles.length;
-        let helper = this._lookupHelper(name, meta);
-        if (helper !== null) {
-            let handle = this.handle(helper);
-            if (nextHandle === handle) {
-                this.helperDefinitionCount++;
-            }
-            return handle;
-        }
-        return null;
-    }
-    /**
-     * Called by CompileTimeLookup compiling the
-     */
-    lookupModifier(name, _meta) {
-        return this.handle(this._lookupModifier(name));
-    }
-    /**
-     * Called by CompileTimeLookup to lookup partial
-     */
-    lookupPartial(name, meta) {
-        let partial = this._lookupPartial(name, meta);
-        return this.handle(partial);
-    }
-    // end CompileTimeLookup
-    /**
-     * Creates a template with injections from a directly imported template factory.
-     * @param templateFactory the directly imported template factory.
-     * @param owner the owner the template instance would belong to if resolved
-     */
-    createTemplate(factory, owner) {
-        let cache = this.templateCache.get(owner);
-        if (cache === undefined) {
-            cache = new Map();
-            this.templateCache.set(owner, cache);
-        }
-        let template = cache.get(factory);
-        if (template === undefined) {
-            const { compiler } = this;
-            const injections = { compiler };
-            setOwner(injections, owner);
-            template = factory.create(injections);
-            cache.set(factory, template);
-            this.templateCacheMisses++;
-        }
-        else {
-            this.templateCacheHits++;
-        }
-        return template;
-    }
-    // needed for lazy compile time lookup
-    handle(obj) {
-        if (obj === undefined || obj === null) {
-            return null;
-        }
-        let handle = this.objToHandle.get(obj);
-        if (handle === undefined) {
-            handle = this.handles.push(obj) - 1;
-            this.objToHandle.set(obj, handle);
-        }
-        return handle;
-    }
-    _lookupHelper(_name, meta) {
-        const helper = this.builtInHelpers[_name];
-        if (helper !== undefined) {
-            return helper;
-        }
-        const { owner, moduleName } = meta;
-        let name = _name;
-        let namespace = undefined;
-        if (EMBER_MODULE_UNIFICATION) {
-            const parsed = this._parseNameForNamespace(_name);
-            name = parsed.name;
-            namespace = parsed.namespace;
-        }
-        const options = makeOptions(moduleName, namespace);
-        const factory = owner.factoryFor(`helper:${name}`, options) || owner.factoryFor(`helper:${name}`);
-        if (!isHelperFactory(factory)) {
-            return null;
-        }
-        return (vm, args) => {
-            const helper = factory.create();
-            if (isSimpleHelper(helper)) {
-                return new SimpleHelperReference(helper.compute, args.capture());
-            }
-            vm.newDestroyable(helper);
-            return ClassBasedHelperReference.create(helper, args.capture());
-        };
-    }
-    _lookupPartial(name, meta) {
-        const template = lookupPartial(name, meta.owner);
-        if (template) {
-            return new PartialDefinition(name, template);
-        }
-        else {
-            throw new Error(`${name} is not a partial`);
-        }
-    }
-    _lookupModifier(name) {
-        return this.builtInModifiers[name];
-    }
-    _parseNameForNamespace(_name) {
-        let name = _name;
-        let namespace = undefined;
-        let namespaceDelimiterOffset = _name.indexOf('::');
-        if (namespaceDelimiterOffset !== -1) {
-            name = _name.slice(namespaceDelimiterOffset + 2);
-            namespace = _name.slice(0, namespaceDelimiterOffset);
-        }
-        return { name, namespace };
-    }
-    _lookupComponentDefinition(_name, meta) {
-        let name = _name;
-        let namespace = undefined;
-        if (EMBER_MODULE_UNIFICATION) {
-            const parsed = this._parseNameForNamespace(_name);
-            name = parsed.name;
-            namespace = parsed.namespace;
-        }
-        let { layout, component } = lookupComponent(meta.owner, name, makeOptions(meta.moduleName, namespace));
-        let key = component === undefined ? layout : component;
-        if (key === undefined) {
-            return null;
-        }
-        let cachedComponentDefinition = this.componentDefinitionCache.get(key);
-        if (cachedComponentDefinition !== undefined) {
-            return cachedComponentDefinition;
-        }
-        let finalizer = _instrumentStart('render.getComponentDefinition', instrumentationPayload, name);
-        if (layout && !component && ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
-            let definition = new TemplateOnlyComponentDefinition(layout);
-            finalizer();
-            this.componentDefinitionCache.set(key, definition);
-            return definition;
-        }
-        if (GLIMMER_CUSTOM_COMPONENT_MANAGER && component && component.class) {
-            let managerId = getComponentManager(component.class);
-            if (managerId) {
-                let manager = this._lookupComponentManager(meta.owner, managerId);
-                assert(`Could not find custom component manager '${managerId}' which was specified by ${component.class}`, !!manager);
-                let definition = new CustomManagerDefinition(name, component, manager, layout || meta.owner.lookup(P `template:components/-default`));
-                finalizer();
-                this.componentDefinitionCache.set(key, definition);
-                return definition;
-            }
-        }
-        let definition = layout || component
-            ? new CurlyComponentDefinition(name, component || meta.owner.factoryFor(P `component:-default`), null, layout // TODO fix type
-            )
-            : null;
-        finalizer();
-        this.componentDefinitionCache.set(key, definition);
-        return definition;
-    }
-    _lookupComponentManager(owner, managerId) {
-        if (this.customManagerCache.has(managerId)) {
-            return this.customManagerCache.get(managerId);
-        }
-        let delegate = owner.lookup(`component-manager:${managerId}`);
-        this.customManagerCache.set(managerId, delegate);
-        return delegate;
-    }
-}

data/dist/es/ember-glimmer/lib/setup-registry.js

@@ -1,77 +0,0 @@
-import { privatize as P } from 'container';
-import { hasDOM } from 'ember-browser-environment';
-import { ENV } from 'ember-environment';
-import Component from './component';
-import Checkbox from './components/checkbox';
-import LinkToComponent from './components/link-to';
-import TextArea from './components/text_area';
-import TextField from './components/text_field';
-import { clientBuilder, DOMChanges, DOMTreeConstruction, NodeDOMTreeConstruction, rehydrationBuilder, serializeBuilder, } from './dom';
-import Environment from './environment';
-import loc from './helpers/loc';
-import { InertRenderer, InteractiveRenderer } from './renderer';
-import TemplateCompiler from './template-compiler';
-import ComponentTemplate from './templates/component';
-import OutletTemplate from './templates/outlet';
-import RootTemplate from './templates/root';
-import OutletView from './views/outlet';
-export function setupApplicationRegistry(registry) {
-    registry.injection('service:-glimmer-environment', 'appendOperations', 'service:-dom-tree-construction');
-    registry.injection('renderer', 'env', 'service:-glimmer-environment');
-    // because we are using injections we can't use instantiate false
-    // we need to use bind() to copy the function so factory for
-    // association won't leak
-    registry.register('service:-dom-builder', {
-        create({ bootOptions }) {
-            let { _renderMode } = bootOptions;
-            switch (_renderMode) {
-                case 'serialize':
-                    return serializeBuilder.bind(null);
-                case 'rehydrate':
-                    return rehydrationBuilder.bind(null);
-                default:
-                    return clientBuilder.bind(null);
-            }
-        },
-    });
-    registry.injection('service:-dom-builder', 'bootOptions', '-environment:main');
-    registry.injection('renderer', 'builder', 'service:-dom-builder');
-    registry.register(P `template:-root`, RootTemplate);
-    registry.injection('renderer', 'rootTemplate', P `template:-root`);
-    registry.register('renderer:-dom', InteractiveRenderer);
-    registry.register('renderer:-inert', InertRenderer);
-    if (hasDOM) {
-        registry.injection('service:-glimmer-environment', 'updateOperations', 'service:-dom-changes');
-    }
-    registry.register('service:-dom-changes', {
-        create({ document }) {
-            return new DOMChanges(document);
-        },
-    });
-    registry.register('service:-dom-tree-construction', {
-        create({ document }) {
-            let Implementation = hasDOM ? DOMTreeConstruction : NodeDOMTreeConstruction;
-            return new Implementation(document);
-        },
-    });
-}
-export function setupEngineRegistry(registry) {
-    registry.register('view:-outlet', OutletView);
-    registry.register('template:-outlet', OutletTemplate);
-    registry.injection('view:-outlet', 'template', 'template:-outlet');
-    registry.injection('service:-dom-changes', 'document', 'service:-document');
-    registry.injection('service:-dom-tree-construction', 'document', 'service:-document');
-    registry.register(P `template:components/-default`, ComponentTemplate);
-    registry.register('service:-glimmer-environment', Environment);
-    registry.register(P `template-compiler:main`, TemplateCompiler);
-    registry.injection('template', 'compiler', P `template-compiler:main`);
-    registry.optionsForType('helper', { instantiate: false });
-    registry.register('helper:loc', loc);
-    registry.register('component:-text-field', TextField);
-    registry.register('component:-text-area', TextArea);
-    registry.register('component:-checkbox', Checkbox);
-    registry.register('component:link-to', LinkToComponent);
-    if (!ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
-        registry.register(P `component:-default`, Component);
-    }
-}

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

@@ -1,73 +0,0 @@
-import { EMBER_TEMPLATE_BLOCK_LET_HELPER } from '@ember/canary-features';
-import { assert } from '@ember/debug';
-import { RENDER_HELPER } from '@ember/deprecated-features';
-import { textAreaMacro } from './syntax/-text-area';
-import { inputMacro } from './syntax/input';
-import { blockLetMacro } from './syntax/let';
-import { mountMacro } from './syntax/mount';
-import { outletMacro } from './syntax/outlet';
-import { renderMacro } from './syntax/render';
-import { hashToArgs } from './syntax/utils';
-import { wrapComponentClassAttribute } from './utils/bindings';
-function refineInlineSyntax(name, params, hash, builder) {
-    assert(`You attempted to overwrite the built-in helper "${name}" which is not allowed. Please rename the helper.`, !(builder.compiler['resolver']['resolver']['builtInHelpers'][name] &&
-        builder.referrer.owner.hasRegistration(`helper:${name}`)));
-    if (name.indexOf('-') === -1) {
-        return false;
-    }
-    let handle = builder.compiler['resolver'].lookupComponentDefinition(name, builder.referrer);
-    if (handle !== null) {
-        builder.component.static(handle, [params === null ? [] : params, hashToArgs(hash), null, null]);
-        return true;
-    }
-    return false;
-}
-function refineBlockSyntax(name, params, hash, template, inverse, builder) {
-    if (name.indexOf('-') === -1) {
-        return false;
-    }
-    let handle = builder.compiler['resolver'].lookupComponentDefinition(name, builder.referrer);
-    if (handle !== null) {
-        wrapComponentClassAttribute(hash);
-        builder.component.static(handle, [params, hashToArgs(hash), template, inverse]);
-        return true;
-    }
-    assert(`A component or helper named "${name}" could not be found`, builder.referrer.owner.hasRegistration(`helper:${name}`));
-    assert(`Helpers may not be used in the block form, for example {{#${name}}}{{/${name}}}. Please use a component, or alternatively use the helper in combination with a built-in Ember helper, for example {{#if (${name})}}{{/if}}.`, !(() => {
-        const resolver = builder.compiler['resolver']['resolver'];
-        const { owner, moduleName } = builder.referrer;
-        if (name === 'component' || resolver['builtInHelpers'][name]) {
-            return true;
-        }
-        let options = { source: `template:${moduleName}` };
-        return (owner.hasRegistration(`helper:${name}`, options) || owner.hasRegistration(`helper:${name}`));
-    })());
-    return false;
-}
-export const experimentalMacros = [];
-// This is a private API to allow for experimental macros
-// to be created in user space. Registering a macro should
-// should be done in an initializer.
-export function registerMacros(macro) {
-    experimentalMacros.push(macro);
-}
-export function populateMacros(macros) {
-    let { inlines, blocks } = macros;
-    inlines.add('outlet', outletMacro);
-    if (RENDER_HELPER) {
-        inlines.add('render', renderMacro);
-    }
-    inlines.add('mount', mountMacro);
-    inlines.add('input', inputMacro);
-    inlines.add('textarea', textAreaMacro);
-    inlines.addMissing(refineInlineSyntax);
-    if (EMBER_TEMPLATE_BLOCK_LET_HELPER === true) {
-        blocks.add('let', blockLetMacro);
-    }
-    blocks.addMissing(refineBlockSyntax);
-    for (let i = 0; i < experimentalMacros.length; i++) {
-        let macro = experimentalMacros[i];
-        macro(blocks, inlines);
-    }
-    return { blocks, inlines };
-}

data/dist/es/ember-glimmer/lib/syntax/-text-area.js

@@ -1,8 +0,0 @@
-import { wrapComponentClassAttribute } from '../utils/bindings';
-import { hashToArgs } from './utils';
-export function textAreaMacro(_name, params, hash, builder) {
-    let definition = builder.compiler['resolver'].lookupComponentDefinition('-text-area', builder.referrer);
-    wrapComponentClassAttribute(hash);
-    builder.component.static(definition, [params || [], hashToArgs(hash), null, null]);
-    return true;
-}