discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-template-compiler/lib/plugins/transform-dot-component-invocation.js

@@ -1,88 +0,0 @@
-/**
-  Transforms dot invocation of closure components to be wrapped
-  with the component helper. This allows for a more static invocation
-  of the component.
-
-  ```handlebars
- {{#my-component as |comps|}}
-  {{comp.dropdown isOpen=false}}
- {{/my-component}}
-  ```
-
-  with
-
-  ```handlebars
-  {{#my-component as |comps|}}
-    {{component comp.dropdown isOpen=false}}
-  {{/my-component}}
-  ```
-  and
-
-  ```handlebars
- {{#my-component as |comps|}}
-  {{comp.dropdown isOpen}}
- {{/my-component}}
-  ```
-
-  with
-
-  ```handlebars
-  {{#my-component as |comps|}}
-    {{component comp.dropdown isOpen}}
-  {{/my-component}}
-  ```
-
-  and
-
-  ```handlebars
-  {{#my-component as |comps|}}
-    {{#comp.dropdown}}Open{{/comp.dropdown}}
-  {{/my-component}}
-  ```
-
-  with
-
-  ```handlebars
-  {{#my-component as |comps|}}
-    {{#component comp.dropdown}}Open{{/component}}
-  {{/my-component}}
-  ```
-
-  @private
-  @class TransFormDotComponentInvocation
-*/
-export default function transformDotComponentInvocation(env) {
-    let { builders: b } = env.syntax;
-    return {
-        name: 'transform-dot-component-invocation',
-        visitor: {
-            MustacheStatement(node) {
-                if (isInlineInvocation(node.path, node.params, node.hash)) {
-                    wrapInComponent(node, b);
-                }
-            },
-            BlockStatement(node) {
-                if (isMultipartPath(node.path)) {
-                    wrapInComponent(node, b);
-                }
-            },
-        },
-    };
-}
-function isMultipartPath(path) {
-    return path.parts && path.parts.length > 1;
-}
-function isInlineInvocation(path, params, hash) {
-    if (isMultipartPath(path)) {
-        if (params.length > 0 || hash.pairs.length > 0) {
-            return true;
-        }
-    }
-    return false;
-}
-function wrapInComponent(node, builder) {
-    let component = node.path;
-    let componentHelper = builder.path('component');
-    node.path = componentHelper;
-    node.params.unshift(component);
-}

data/dist/es/ember-template-compiler/lib/plugins/transform-each-in-into-each.js

@@ -1,48 +0,0 @@
-/**
- @module ember
-*/
-/**
-  A Glimmer2 AST transformation that replaces all instances of
-
-  ```handlebars
- {{#each-in iterableThing as |key value|}}
-  ```
-
-  with
-
-  ```handlebars
- {{#each (-each-in iterableThing) as |value key|}}
-  ```
-
-  @private
-  @class TransformHasBlockSyntax
-*/
-export default function transformEachInIntoEach(env) {
-    let { builders: b } = env.syntax;
-    return {
-        name: 'transform-each-in-into-each',
-        visitor: {
-            BlockStatement(node) {
-                if (node.path.original === 'each-in') {
-                    node.params[0] = b.sexpr(b.path('-each-in'), [node.params[0]]);
-                    let blockParams = node.program.blockParams;
-                    if (!blockParams || blockParams.length === 0) {
-                        // who uses {{#each-in}} without block params?!
-                    }
-                    else if (blockParams.length === 1) {
-                        // insert a dummy variable for the first slot
-                        // pick a name that won't parse so it won't shadow any real variables
-                        blockParams = ['( unused value )', blockParams[0]];
-                    }
-                    else {
-                        let key = blockParams.shift();
-                        let value = blockParams.shift();
-                        blockParams = [value, key, ...blockParams];
-                    }
-                    node.program.blockParams = blockParams;
-                    return b.block(b.path('each'), node.params, node.hash, node.program, node.inverse, node.loc);
-                }
-            },
-        },
-    };
-}

data/dist/es/ember-template-compiler/lib/plugins/transform-has-block-syntax.js

@@ -1,46 +0,0 @@
-/**
- @module ember
-*/
-/**
-  A Glimmer2 AST transformation that replaces all instances of
-
-  ```handlebars
- {{hasBlock}}
-  ```
-
-  with
-
-  ```handlebars
- {{has-block}}
-  ```
-
-  @private
-  @class TransformHasBlockSyntax
-*/
-const TRANSFORMATIONS = {
-    hasBlock: 'has-block',
-    hasBlockParams: 'has-block-params',
-};
-export default function transformHasBlockSyntax(env) {
-    let { builders: b } = env.syntax;
-    return {
-        name: 'transform-has-block-syntax',
-        visitor: {
-            PathExpression(node) {
-                if (TRANSFORMATIONS[node.original]) {
-                    return b.sexpr(b.path(TRANSFORMATIONS[node.original]));
-                }
-            },
-            MustacheStatement(node) {
-                if (typeof node.path.original === 'string' && TRANSFORMATIONS[node.path.original]) {
-                    return b.mustache(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash, undefined, node.loc);
-                }
-            },
-            SubExpression(node) {
-                if (TRANSFORMATIONS[node.path.original]) {
-                    return b.sexpr(b.path(TRANSFORMATIONS[node.path.original]), node.params, node.hash);
-                }
-            },
-        },
-    };
-}

data/dist/es/ember-template-compiler/lib/plugins/transform-in-element.js

@@ -1,83 +0,0 @@
-import { assert } from '@ember/debug';
-import calculateLocationDisplay from '../system/calculate-location-display';
-/**
- @module ember
-*/
-/**
-  glimmer-vm has made the `in-element` API public from its perspective (in
-  https://github.com/glimmerjs/glimmer-vm/pull/619) so in glimmer-vm the
-  correct keyword to use is `in-element`, however Ember is still working through
-  its form of `in-element` (see https://github.com/emberjs/rfcs/pull/287).
-
-  There are enough usages of the pre-existing private API (`{{-in-element`) in
-  the wild that we need to transform `{{-in-element` into `{{in-element` during
-  template transpilation, but since RFC#287 is not landed and enabled by default we _also_ need
-  to prevent folks from starting to use `{{in-element` "for realz".
-
-  Tranforms:
-
-  ```handlebars
-  {{#-in-element someElement}}
-    {{modal-display text=text}}
-  {{/-in-element}}
-  ```
-
-  into:
-
-  ```handlebars
-  {{#in-element someElement}}
-    {{modal-display text=text}}
-  {{/in-element}}
-  ```
-
-  And issues a build time assertion for:
-
-  ```handlebars
-  {{#in-element someElement}}
-    {{modal-display text=text}}
-  {{/in-element}}
-  ```
-
-  @private
-  @class TransformHasBlockSyntax
-*/
-export default function transformInElement(env) {
-    let { moduleName } = env.meta;
-    let { builders: b } = env.syntax;
-    let cursorCount = 0;
-    return {
-        name: 'transform-in-element',
-        visitor: {
-            BlockStatement(node) {
-                if (node.path.original === 'in-element') {
-                    assert(assertMessage(moduleName, node));
-                }
-                else if (node.path.original === '-in-element') {
-                    node.path.original = 'in-element';
-                    node.path.parts = ['in-element'];
-                    // replicate special hash arguments added here:
-                    // https://github.com/glimmerjs/glimmer-vm/blob/ba9b37d44b85fa1385eeeea71910ff5798198c8e/packages/%40glimmer/syntax/lib/parser/handlebars-node-visitors.ts#L340-L363
-                    let hasNextSibling = false;
-                    let hash = node.hash;
-                    hash.pairs.forEach(pair => {
-                        if (pair.key === 'nextSibling') {
-                            hasNextSibling = true;
-                        }
-                    });
-                    let guid = b.literal('StringLiteral', `%cursor:${cursorCount++}%`);
-                    let guidPair = b.pair('guid', guid);
-                    hash.pairs.unshift(guidPair);
-                    if (!hasNextSibling) {
-                        let nullLiteral = b.literal('NullLiteral', null);
-                        let nextSibling = b.pair('nextSibling', nullLiteral);
-                        hash.pairs.push(nextSibling);
-                    }
-                }
-            },
-        },
-    };
-}
-function assertMessage(moduleName, node) {
-    let sourceInformation = calculateLocationDisplay(moduleName, node.loc);
-    return `The {{in-element}} helper cannot be used. ${sourceInformation}`;
-}

data/dist/es/ember-template-compiler/lib/plugins/transform-inline-link-to.js

@@ -1,31 +0,0 @@
-function buildProgram(b, content, loc) {
-    return b.program([buildStatement(b, content, loc)], undefined, loc);
-}
-function buildStatement(b, content, loc) {
-    switch (content.type) {
-        case 'PathExpression':
-            return b.mustache(content, undefined, undefined, undefined, loc);
-        case 'SubExpression':
-            return b.mustache(content.path, content.params, content.hash, undefined, loc);
-        // The default case handles literals.
-        default:
-            return b.text(`${content.value}`, loc);
-    }
-}
-function unsafeHtml(b, expr) {
-    return b.sexpr('-html-safe', [expr]);
-}
-export default function transformInlineLinkTo(env) {
-    let { builders: b } = env.syntax;
-    return {
-        name: 'transform-inline-link-to',
-        visitor: {
-            MustacheStatement(node) {
-                if (node.path.original === 'link-to') {
-                    let content = node.escaped ? node.params[0] : unsafeHtml(b, node.params[0]);
-                    return b.block('link-to', node.params.slice(1), node.hash, buildProgram(b, content, node.loc), null, node.loc);
-                }
-            },
-        },
-    };
-}

data/dist/es/ember-template-compiler/lib/plugins/transform-input-type-syntax.js

@@ -1,52 +0,0 @@
-/**
- @module ember
-*/
-/**
-  A Glimmer2 AST transformation that replaces all instances of
-
-  ```handlebars
- {{input type=boundType}}
-  ```
-
-  with
-
-  ```handlebars
- {{input (-input-type boundType) type=boundType}}
-  ```
-
-  Note that the type parameters is not removed as the -input-type helpers
-  is only used to select the component class. The component still needs
-  the type parameter to function.
-
-  @private
-  @class TransformInputTypeSyntax
-*/
-export default function transformInputTypeSyntax(env) {
-    let b = env.syntax.builders;
-    return {
-        name: 'transform-input-type-syntax',
-        visitor: {
-            MustacheStatement(node) {
-                if (isInput(node)) {
-                    insertTypeHelperParameter(node, b);
-                }
-            },
-        },
-    };
-}
-function isInput(node) {
-    return node.path.original === 'input';
-}
-function insertTypeHelperParameter(node, builders) {
-    let pairs = node.hash.pairs;
-    let pair = null;
-    for (let i = 0; i < pairs.length; i++) {
-        if (pairs[i].key === 'type') {
-            pair = pairs[i];
-            break;
-        }
-    }
-    if (pair && pair.value.type !== 'StringLiteral') {
-        node.params.unshift(builders.sexpr('-input-type', [pair.value], undefined, pair.loc));
-    }
-}

data/dist/es/ember-template-compiler/lib/plugins/transform-old-binding-syntax.js

@@ -1,48 +0,0 @@
-import { assert, deprecate } from '@ember/debug';
-import { BINDING_SUPPORT } from '@ember/deprecated-features';
-import calculateLocationDisplay from '../system/calculate-location-display';
-export default function transformOldBindingSyntax(env) {
-    if (BINDING_SUPPORT) {
-        let { moduleName } = env.meta;
-        let b = env.syntax.builders;
-        let exprToString = (expr) => {
-            switch (expr.type) {
-                case 'StringLiteral':
-                    return `"${expr.original}"`;
-                case 'PathExpression':
-                    return expr.original;
-            }
-            return '';
-        };
-        let processHash = (node) => {
-            for (let i = 0; i < node.hash.pairs.length; i++) {
-                let pair = node.hash.pairs[i];
-                let { key, value } = pair;
-                let sourceInformation = calculateLocationDisplay(moduleName, pair.loc);
-                if (key === 'classBinding') {
-                    return;
-                }
-                assert(`Setting 'attributeBindings' via template helpers is not allowed ${sourceInformation}`, key !== 'attributeBindings');
-                if (key.substr(-7) === 'Binding') {
-                    let newKey = key.slice(0, -7);
-                    deprecate(`You're using legacy binding syntax: ${key}=${exprToString(value)} ${sourceInformation}. Please replace with ${newKey}=${value.original}`, false, {
-                        id: 'ember-template-compiler.transform-old-binding-syntax',
-                        until: '3.0.0',
-                    });
-                    pair.key = newKey;
-                    if (value.type === 'StringLiteral') {
-                        pair.value = b.path(value.original);
-                    }
-                }
-            }
-        };
-        return {
-            name: 'transform-old-binding-syntax',
-            visitor: {
-                BlockStatement: processHash,
-                MustacheStatement: processHash,
-            },
-        };
-    }
-    return undefined;
-}

data/dist/es/ember-template-compiler/lib/plugins/transform-old-class-binding-syntax.js

@@ -1,102 +0,0 @@
-export default function transformOldClassBindingSyntax(env) {
-    let b = env.syntax.builders;
-    return {
-        name: 'transform-old-class-binding-syntax',
-        visitor: {
-            MustacheStatement(node) {
-                process(b, node);
-            },
-            BlockStatement(node) {
-                process(b, node);
-            },
-        },
-    };
-}
-function process(b, node) {
-    let allOfTheMicrosyntaxes = [];
-    let allOfTheMicrosyntaxIndexes = [];
-    let classPair;
-    each(node.hash.pairs, (pair, index) => {
-        let { key } = pair;
-        if (key === 'classBinding' || key === 'classNameBindings') {
-            allOfTheMicrosyntaxIndexes.push(index);
-            allOfTheMicrosyntaxes.push(pair);
-        }
-        else if (key === 'class') {
-            classPair = pair;
-        }
-    });
-    if (allOfTheMicrosyntaxes.length === 0) {
-        return;
-    }
-    let classValue = [];
-    if (classPair) {
-        classValue.push(classPair.value);
-        classValue.push(b.string(' '));
-    }
-    else {
-        classPair = b.pair('class', null);
-        node.hash.pairs.push(classPair);
-    }
-    each(allOfTheMicrosyntaxIndexes, index => {
-        node.hash.pairs.splice(index, 1);
-    });
-    each(allOfTheMicrosyntaxes, ({ value }) => {
-        let sexprs = [];
-        // TODO: add helpful deprecation when both `classNames` and `classNameBindings` can
-        // be removed.
-        if (value.type === 'StringLiteral') {
-            let microsyntax = parseMicrosyntax(value.original);
-            buildSexprs(microsyntax, sexprs, b);
-            classValue.push(...sexprs);
-        }
-    });
-    let hash = b.hash();
-    classPair.value = b.sexpr(b.path('concat'), classValue, hash);
-}
-function buildSexprs(microsyntax, sexprs, b) {
-    for (let i = 0; i < microsyntax.length; i++) {
-        let [propName, activeClass, inactiveClass] = microsyntax[i];
-        let sexpr;
-        // :my-class-name microsyntax for static values
-        if (propName === '') {
-            sexpr = b.string(activeClass);
-        }
-        else {
-            let params = [b.path(propName)];
-            if (activeClass || activeClass === '') {
-                params.push(b.string(activeClass));
-            }
-            else {
-                let sexprParams = [b.string(propName), b.path(propName)];
-                let hash = b.hash();
-                if (activeClass !== undefined) {
-                    hash.pairs.push(b.pair('activeClass', b.string(activeClass)));
-                }
-                if (inactiveClass !== undefined) {
-                    hash.pairs.push(b.pair('inactiveClass', b.string(inactiveClass)));
-                }
-                params.push(b.sexpr(b.path('-normalize-class'), sexprParams, hash));
-            }
-            if (inactiveClass || inactiveClass === '') {
-                params.push(b.string(inactiveClass));
-            }
-            sexpr = b.sexpr(b.path('if'), params);
-        }
-        sexprs.push(sexpr);
-        sexprs.push(b.string(' '));
-    }
-}
-function each(list, callback) {
-    for (let i = 0; i < list.length; i++) {
-        callback(list[i], i);
-    }
-}
-function parseMicrosyntax(string) {
-    let segments = string.split(' ');
-    let ret = [];
-    for (let i = 0; i < segments.length; i++) {
-        ret[i] = segments[i].split(':');
-    }
-    return ret;
-}