discourse-ember-source 3.5.1.1 → 3.5.1.2

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

@@ -1,173 +0,0 @@
-/**
-@module ember
-*/
-import { assert } from '@ember/debug';
-import { wrapComponentClassAttribute } from '../utils/bindings';
-import { hashToArgs } from './utils';
-function buildSyntax(type, params, hash, builder) {
-    let definition = builder.compiler['resolver'].lookupComponentDefinition(type, builder.referrer);
-    builder.component.static(definition, [params, hashToArgs(hash), null, null]);
-    return true;
-}
-/**
-  The `{{input}}` helper lets you create an HTML `<input />` component.
-  It causes an `TextField` component to be rendered.  For more info,
-  see the [TextField](/api/ember/release/classes/TextField) docs and
-  the [templates guide](https://guides.emberjs.com/release/templates/input-helpers/).
-
-  ```handlebars
-  {{input value="987"}}
-  ```
-
-  renders as:
-
-  ```HTML
-  <input type="text" value="987" />
-  ```
-
-  ### Text field
-
-  If no `type` option is specified, a default of type 'text' is used.
-  Many of the standard HTML attributes may be passed to this helper.
-  <table>
-    <tr><td>`readonly`</td><td>`required`</td><td>`autofocus`</td></tr>
-    <tr><td>`value`</td><td>`placeholder`</td><td>`disabled`</td></tr>
-    <tr><td>`size`</td><td>`tabindex`</td><td>`maxlength`</td></tr>
-    <tr><td>`name`</td><td>`min`</td><td>`max`</td></tr>
-    <tr><td>`pattern`</td><td>`accept`</td><td>`autocomplete`</td></tr>
-    <tr><td>`autosave`</td><td>`formaction`</td><td>`formenctype`</td></tr>
-    <tr><td>`formmethod`</td><td>`formnovalidate`</td><td>`formtarget`</td></tr>
-    <tr><td>`height`</td><td>`inputmode`</td><td>`multiple`</td></tr>
-    <tr><td>`step`</td><td>`width`</td><td>`form`</td></tr>
-    <tr><td>`selectionDirection`</td><td>`spellcheck`</td><td>&nbsp;</td></tr>
-  </table>
-  When set to a quoted string, these values will be directly applied to the HTML
-  element. When left unquoted, these values will be bound to a property on the
-  template's current rendering context (most typically a controller instance).
-  A very common use of this helper is to bind the `value` of an input to an Object's attribute:
-
-  ```handlebars
-  Search:
-  {{input value=searchWord}}
-  ```
-
-  In this example, the initial value in the `<input />` will be set to the value of `searchWord`.
-  If the user changes the text, the value of `searchWord` will also be updated.
-
-  ### Actions
-
-  The helper can send multiple actions based on user events.
-  The action property defines the action which is sent when
-  the user presses the return key.
-
-  ```handlebars
-  {{input action="submit"}}
-  ```
-
-  The helper allows some user events to send actions.
-
-  * `enter`
-  * `insert-newline`
-  * `escape-press`
-  * `focus-in`
-  * `focus-out`
-  * `key-press`
-  * `key-up`
-
-  For example, if you desire an action to be sent when the input is blurred,
-  you only need to setup the action name to the event name property.
-
-  ```handlebars
-  {{input focus-out="alertMessage"}}
-  ```
-  See more about [Text Support Actions](/api/ember/release/classes/TextField)
-
-  ### Extending `TextField`
-
-  Internally, `{{input type="text"}}` creates an instance of `TextField`, passing
-  arguments from the helper to `TextField`'s `create` method. You can extend the
-  capabilities of text inputs in your applications by reopening this class. For example,
-  if you are building a Bootstrap project where `data-*` attributes are used, you
-  can add one to the `TextField`'s `attributeBindings` property:
-
-  ```javascript
-  import TextField from '@ember/component/text-field';
-  TextField.reopen({
-    attributeBindings: ['data-error']
-  });
-  ```
-
-  Keep in mind when writing `TextField` subclasses that `TextField`
-  itself extends `Component`. Expect isolated component semantics, not
-  legacy 1.x view semantics (like `controller` being present).
-  See more about [Ember components](/api/ember/release/classes/Component)
-
-  ### Checkbox
-
-  Checkboxes are special forms of the `{{input}}` helper.  To create a `<checkbox />`:
-
-  ```handlebars
-  Emberize Everything:
-  {{input type="checkbox" name="isEmberized" checked=isEmberized}}
-  ```
-
-  This will bind checked state of this checkbox to the value of `isEmberized`  -- if either one changes,
-  it will be reflected in the other.
-
-  The following HTML attributes can be set via the helper:
-
-  * `checked`
-  * `disabled`
-  * `tabindex`
-  * `indeterminate`
-  * `name`
-  * `autofocus`
-  * `form`
-
-  ### Extending `Checkbox`
-
-  Internally, `{{input type="checkbox"}}` creates an instance of `Checkbox`, passing
-  arguments from the helper to `Checkbox`'s `create` method. You can extend the
-  capablilties of checkbox inputs in your applications by reopening this class. For example,
-  if you wanted to add a css class to all checkboxes in your application:
-
-  ```javascript
-  import Checkbox from '@ember/component/checkbox';
-
-  Checkbox.reopen({
-    classNames: ['my-app-checkbox']
-  });
-  ```
-
-  @method input
-  @for Ember.Templates.helpers
-  @param {Hash} options
-  @public
-*/
-export function inputMacro(_name, params, hash, builder) {
-    if (params === null) {
-        params = [];
-    }
-    if (hash !== null) {
-        let keys = hash[0];
-        let values = hash[1];
-        let typeIndex = keys.indexOf('type');
-        if (typeIndex > -1) {
-            let typeArg = values[typeIndex];
-            if (Array.isArray(typeArg)) {
-                // there is an AST plugin that converts this to an expression
-                // it really should just compile in the component call too.
-                let inputTypeExpr = params[0];
-                builder.dynamicComponent(inputTypeExpr, null, params.slice(1), hash, true, null, null);
-                return true;
-            }
-            if (typeArg === 'checkbox') {
-                assert("{{input type='checkbox'}} does not support setting `value=someBooleanValue`; " +
-                    'you must use `checked=someBooleanValue` instead.', keys.indexOf('value') === -1);
-                wrapComponentClassAttribute(hash);
-                return buildSyntax('-checkbox', params, hash, builder);
-            }
-        }
-    }
-    return buildSyntax('-text-field', params, hash, builder);
-}

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

@@ -1,50 +0,0 @@
-/**
-@module ember
-*/
-/**
-    The `let` helper receives one or more positional arguments and yields
-    them out as block params.
-
-    This allows the developer to introduce shorter names for certain computations
-    in the template.
-
-    This is especially useful if you are passing properties to a component
-    that receives a lot of options and you want to clean up the invocation.
-
-    For the following example, the template receives a `post` object with
-    `content` and `title` properties.
-
-    We are going to call the `my-post` component, passing a title which is
-    the title of the post suffixed with the name of the blog, the content
-    of the post, and a series of options defined in-place.
-
-    ```handlebars
-    {{#let
-        (concat post.title ' | The Ember.js Blog')
-        post.content
-        (hash
-          theme="high-contrast"
-          enableComments=true
-        )
-        as |title content options|
-    }}
-      {{my-post title=title content=content options=options}}
-    {{/let}}
-  ```
-
-  @method let
-  @for Ember.Templates.helpers
-  @public
-*/
-export function blockLetMacro(params, _hash, template, _inverse, builder) {
-    if (template !== null) {
-        if (params !== null) {
-            builder.compileParams(params);
-            builder.invokeStaticBlock(template, params.length);
-        }
-        else {
-            builder.invokeStatic(template);
-        }
-    }
-    return true;
-}

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

@@ -1,101 +0,0 @@
-/**
-@module ember
-*/
-import { EMBER_ENGINES_MOUNT_PARAMS } from '@ember/canary-features';
-import { assert } from '@ember/debug';
-import { curry, UNDEFINED_REFERENCE, } from '@glimmer/runtime';
-import * as WireFormat from '@glimmer/wire-format';
-import { MountDefinition } from '../component-managers/mount';
-export function mountHelper(vm, args) {
-    let env = vm.env;
-    let nameRef = args.positional.at(0);
-    let modelRef = args.named.has('model') ? args.named.get('model') : undefined;
-    return new DynamicEngineReference(nameRef, env, modelRef);
-}
-/**
-  The `{{mount}}` helper lets you embed a routeless engine in a template.
-  Mounting an engine will cause an instance to be booted and its `application`
-  template to be rendered.
-
-  For example, the following template mounts the `ember-chat` engine:
-
-  ```handlebars
-  {{! application.hbs }}
-  {{mount "ember-chat"}}
-  ```
-
-  Additionally, you can also pass in a `model` argument that will be
-  set as the engines model. This can be an existing object:
-
-  ```
-  <div>
-    {{mount 'admin' model=userSettings}}
-  </div>
-  ```
-
-  Or an inline `hash`, and you can even pass components:
-
-  ```
-  <div>
-    <h1>Application template!</h1>
-    {{mount 'admin' model=(hash
-        title='Secret Admin'
-        signInButton=(component 'sign-in-button')
-    )}}
-  </div>
-  ```
-
-  @method mount
-  @param {String} name Name of the engine to mount.
-  @param {Object} [model] Object that will be set as
-                          the model of the engine.
-  @for Ember.Templates.helpers
-  @category ember-application-engines
-  @public
-*/
-export function mountMacro(_name, params, hash, builder) {
-    if (EMBER_ENGINES_MOUNT_PARAMS) {
-        assert('You can only pass a single positional argument to the {{mount}} helper, e.g. {{mount "chat-engine"}}.', params.length === 1);
-    }
-    else {
-        assert('You can only pass a single argument to the {{mount}} helper, e.g. {{mount "chat-engine"}}.', params.length === 1 && hash === null);
-    }
-    let expr = [WireFormat.Ops.Helper, '-mount', params || [], hash];
-    builder.dynamicComponent(expr, null, [], null, false, null, null);
-    return true;
-}
-class DynamicEngineReference {
-    constructor(nameRef, env, modelRef) {
-        this.tag = nameRef.tag;
-        this.nameRef = nameRef;
-        this.modelRef = modelRef;
-        this.env = env;
-        this._lastName = null;
-        this._lastDef = null;
-    }
-    value() {
-        let { env, nameRef, modelRef } = this;
-        let name = nameRef.value();
-        if (typeof name === 'string') {
-            if (this._lastName === name) {
-                return this._lastDef;
-            }
-            assert(`You used \`{{mount '${name}'}}\`, but the engine '${name}' can not be found.`, env.owner.hasRegistration(`engine:${name}`));
-            if (!env.owner.hasRegistration(`engine:${name}`)) {
-                return null;
-            }
-            this._lastName = name;
-            this._lastDef = curry(new MountDefinition(name, modelRef));
-            return this._lastDef;
-        }
-        else {
-            assert(`Invalid engine name '${name}' specified, engine name must be either a string, null or undefined.`, name === null || name === undefined);
-            this._lastDef = null;
-            this._lastName = null;
-            return null;
-        }
-    }
-    get() {
-        return UNDEFINED_REFERENCE;
-    }
-}

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

@@ -1,120 +0,0 @@
-import { ConstReference } from '@glimmer/reference';
-import { curry, UNDEFINED_REFERENCE, } from '@glimmer/runtime';
-import * as WireFormat from '@glimmer/wire-format';
-import { OutletComponentDefinition } from '../component-managers/outlet';
-import { OutletReference } from '../utils/outlet';
-/**
-  The `{{outlet}}` helper lets you specify where a child route will render in
-  your template. An important use of the `{{outlet}}` helper is in your
-  application's `application.hbs` file:
-
-  ```handlebars
-  {{! app/templates/application.hbs }}
-  <!-- header content goes here, and will always display -->
-  {{my-header}}
-  <div class="my-dynamic-content">
-    <!-- this content will change based on the current route, which depends on the current URL -->
-    {{outlet}}
-  </div>
-  <!-- footer content goes here, and will always display -->
-  {{my-footer}}
-  ```
-
-  You may also specify a name for the `{{outlet}}`, which is useful when using more than one
-  `{{outlet}}` in a template:
-
-  ```handlebars
-  {{outlet "menu"}}
-  {{outlet "sidebar"}}
-  {{outlet "main"}}
-  ```
-
-  Your routes can then render into a specific one of these `outlet`s by specifying the `outlet`
-  attribute in your `renderTemplate` function:
-
-  ```app/routes/menu.js
-  import Route from '@ember/routing/route';
-
-  export default Route.extend({
-    renderTemplate() {
-      this.render({ outlet: 'menu' });
-    }
-  });
-  ```
-
-  See the [routing guide](https://guides.emberjs.com/release/routing/rendering-a-template/) for more
-  information on how your `route` interacts with the `{{outlet}}` helper.
-  Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
-
-  @method outlet
-  @param {String} [name]
-  @for Ember.Templates.helpers
-  @public
-*/
-export function outletHelper(vm, args) {
-    let scope = vm.dynamicScope();
-    let nameRef;
-    if (args.positional.length === 0) {
-        nameRef = new ConstReference('main');
-    }
-    else {
-        nameRef = args.positional.at(0);
-    }
-    return new OutletComponentReference(new OutletReference(scope.outletState, nameRef));
-}
-export function outletMacro(_name, params, hash, builder) {
-    let expr = [WireFormat.Ops.Helper, '-outlet', params || [], hash];
-    builder.dynamicComponent(expr, null, [], null, false, null, null);
-    return true;
-}
-class OutletComponentReference {
-    constructor(outletRef) {
-        this.outletRef = outletRef;
-        this.definition = null;
-        this.lastState = null;
-        // The router always dirties the root state.
-        this.tag = outletRef.tag;
-    }
-    value() {
-        let state = stateFor(this.outletRef);
-        if (validate(state, this.lastState)) {
-            return this.definition;
-        }
-        this.lastState = state;
-        let definition = null;
-        if (state !== null) {
-            definition = curry(new OutletComponentDefinition(state));
-        }
-        return (this.definition = definition);
-    }
-    get(_key) {
-        return UNDEFINED_REFERENCE;
-    }
-}
-function stateFor(ref) {
-    let outlet = ref.value();
-    if (outlet === undefined)
-        return null;
-    let render = outlet.render;
-    if (render === undefined)
-        return null;
-    let template = render.template;
-    if (template === undefined)
-        return null;
-    return {
-        ref,
-        name: render.name,
-        outlet: render.outlet,
-        template,
-        controller: render.controller,
-    };
-}
-function validate(state, lastState) {
-    if (state === null) {
-        return lastState === null;
-    }
-    if (lastState === null) {
-        return false;
-    }
-    return state.template === lastState.template && state.controller === lastState.controller;
-}

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

@@ -1,140 +0,0 @@
-/**
- @module ember
-*/
-// Remove after 3.4 once _ENABLE_RENDER_SUPPORT flag is no longer needed.
-import { assert } from '@ember/debug';
-import { RENDER_HELPER } from '@ember/deprecated-features';
-import { isConst } from '@glimmer/reference';
-import { curry } from '@glimmer/runtime';
-import * as WireFormat from '@glimmer/wire-format';
-import { ENV } from 'ember-environment';
-import { NON_SINGLETON_RENDER_MANAGER, RenderDefinition, SINGLETON_RENDER_MANAGER, } from '../component-managers/render';
-import { UnboundReference } from '../utils/references';
-let renderHelper;
-if (RENDER_HELPER) {
-    renderHelper = function renderHelper(vm, args) {
-        let env = vm.env;
-        let nameRef = args.positional.at(0);
-        assert(`The first argument of {{render}} must be quoted, e.g. {{render "sidebar"}}.`, isConst(nameRef));
-        // tslint:disable-next-line:max-line-length
-        assert(`The second argument of {{render}} must be a path, e.g. {{render "post" post}}.`, args.positional.length === 1 || !isConst(args.positional.at(1)));
-        let templateName = nameRef.value();
-        // tslint:disable-next-line:max-line-length
-        assert(`You used \`{{render '${templateName}'}}\`, but '${templateName}' can not be found as a template.`, env.owner.hasRegistration(`template:${templateName}`));
-        let template = env.owner.lookup(`template:${templateName}`);
-        let controllerName;
-        if (args.named.has('controller')) {
-            let controllerNameRef = args.named.get('controller');
-            // tslint:disable-next-line:max-line-length
-            assert(`The controller argument for {{render}} must be quoted, e.g. {{render "sidebar" controller="foo"}}.`, isConst(controllerNameRef));
-            // TODO should be ensuring this to string here
-            controllerName = controllerNameRef.value();
-            // tslint:disable-next-line:max-line-length
-            assert(`The controller name you supplied '${controllerName}' did not resolve to a controller.`, env.owner.hasRegistration(`controller:${controllerName}`));
-        }
-        else {
-            controllerName = templateName;
-        }
-        if (args.positional.length === 1) {
-            let def = new RenderDefinition(controllerName, template, SINGLETON_RENDER_MANAGER);
-            return UnboundReference.create(curry(def));
-        }
-        else {
-            let def = new RenderDefinition(controllerName, template, NON_SINGLETON_RENDER_MANAGER);
-            let captured = args.capture();
-            return UnboundReference.create(curry(def, captured));
-        }
-    };
-}
-/**
-  Calling ``{{render}}`` from within a template will insert another
-  template that matches the provided name. The inserted template will
-  access its properties on its own controller (rather than the controller
-  of the parent template).
-
-  If a view class with the same name exists, the view class also will be used.
-  Note: A given controller may only be used *once* in your app in this manner.
-  A singleton instance of the controller will be created for you.
-
-  Example:
-
-  ```app/controllers/navigation.js
-  import Controller from '@ember/controller';
-
-  export default Controller.extend({
-    who: "world"
-  });
-  ```
-
-  ```handlebars
-  <!-- navigation.hbs -->
-  Hello, {{who}}.
-  ```
-
-  ```handlebars
-  <!-- application.hbs -->
-  <h1>My great app</h1>
-  {{render "navigation"}}
-  ```
-
-  ```html
-  <h1>My great app</h1>
-  <div class='ember-view'>
-    Hello, world.
-  </div>
-  ```
-
-  Optionally you may provide a second argument: a property path
-  that will be bound to the `model` property of the controller.
-  If a `model` property path is specified, then a new instance of the
-  controller will be created and `{{render}}` can be used multiple times
-  with the same name.
-
-  For example if you had this `author` template.
-
-  ```handlebars
-  <div class="author">
-    Written by {{firstName}} {{lastName}}.
-    Total Posts: {{postCount}}
-  </div>
-  ```
-
-  You could render it inside the `post` template using the `render` helper.
-
-  ```handlebars
-  <div class="post">
-    <h1>{{title}}</h1>
-    <div>{{body}}</div>
-    {{render "author" author}}
-  </div>
-  ```
-
-  @method render
-  @for Ember.Templates.helpers
-  @param {String} name
-  @param {Object?} context
-  @param {Hash} options
-  @return {String} HTML string
-  @public
-  @deprecated Use a component instead
-*/
-let renderMacro;
-if (RENDER_HELPER) {
-    renderMacro = function renderMacro(_name, params, hash, builder) {
-        if (RENDER_HELPER && ENV._ENABLE_RENDER_SUPPORT === true) {
-            // TODO needs makeComponentDefinition a helper that returns a curried definition
-            // TODO not sure all args are for definition or component
-            // likely the controller name should be a arg to create?
-            let expr = [
-                WireFormat.Ops.Helper,
-                '-render',
-                params || [],
-                hash,
-            ];
-            builder.dynamicComponent(expr, null, null, null, false, null, null);
-            return true;
-        }
-        return false;
-    };
-}
-export { renderHelper, renderMacro };