[RFC #338] Implement new template helpers

FEATURES.md

@@ -55,3 +55,8 @@ for a detailed explanation.
 * `ember-template-block-let-helper`
 
   Introduce the block form of the `let` helper per [RFC](https://github.com/emberjs/rfcs/blob/78211b11387e7f477264e322687f1ec5ab131361/text/0286-block-let-template-helper.md).
+
+* `ember-basic-template-helpers`
+
+  Introduces several template helpers to perform basic comparisons and boolean operation in templates:
+  `{{eq}}`, `{{not-eq}}`, `{{gt}}`, `{{gte}}`, `{{lt}}`, `{{lte}}`, `{{not}}`, `{{and}}` and `{{or}}`.

packages/@ember/-internals/glimmer/lib/helpers/and.ts

@@ -0,0 +1,37 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Evaluates the given arguments with && in short-circuit
+
+  Example:
+
+  ```handlebars
+  {{and isAdmin isIdle validData}}
+
+  {{! be validData if `isAdmin` and `isIdle` are both truthy}}
+  ```
+
+  @public
+  @method and
+  @for Ember.Templates.helpers
+  @since 3.7.0
+*/
+function and({ positional: { references } }: CapturedArguments) {
+  let last: any = true;
+  for (let i = 0; i < references.length; i++) {
+    last = references[i].value();
+    if (!last) {
+      return last;
+    }
+  }
+  return last;
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(and, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/eq.ts

@@ -0,0 +1,30 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Compares the two given values with ===
+
+  Example:
+
+  ```handlebars
+  {{eq type "button"}}
+
+  {{! be true if `type` is "button"}}
+  ```
+
+  @public
+  @method eq
+  @for Ember.Templates.helpers
+  @since 3.7.0
+*/
+function eq({ positional: { references } }: CapturedArguments) {
+  return references[0].value() === references[1].value();
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(eq, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/gt.ts

@@ -0,0 +1,41 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Compares the two given values with >
+
+  Example:
+
+  ```handlebars
+  {{gt age 17}}
+
+  {{! be true if `age` is > 17}}
+  ```
+
+  @public
+  @method gt
+  @for Ember.Templates.helpers
+  @since 3.7.0
+*/
+function gt({ positional: { references } }: CapturedArguments) {
+  let left = references[0].value();
+  if (left === undefined || left === null) {
+    return false;
+  }
+  let right = references[1].value();
+  if (right === undefined) {
+    return false;
+  }
+  if (right === null) {
+    return left > 0;
+  }
+  return left > right;
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(gt, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/gte.ts

@@ -0,0 +1,41 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Compares the two given values with >=
+
+  Example:
+
+  ```handlebars
+  {{gt age 17}}
+
+  {{! be true if `age` is > 17}}
+  ```
+
+  @public
+  @method gte
+  @for Ember.Templates.helpers
+  @since 3.7.0
+*/
+function gte({ positional: { references } }: CapturedArguments) {
+  let left = references[0].value();
+  if (left === undefined || left === null) {
+    return false;
+  }
+  let right = references[1].value();
+  if (right === undefined) {
+    return false;
+  }
+  if (right === null) {
+    return left >= 0;
+  }
+  return left >= right;
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(gte, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/lt.ts

@@ -0,0 +1,41 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Compares the two given values with <
+
+  Example:
+
+  ```handlebars
+  {{lt age 17}}
+
+  {{! be true if `age` is < 17}}
+  ```
+
+  @public
+  @method lt
+  @for Ember.Templates.helpers
+  @since 2.7.0
+*/
+function lt({ positional: { references } }: CapturedArguments) {
+  let left = references[0].value();
+  if (left === undefined || left === null) {
+    return false;
+  }
+  let right = references[1].value();
+  if (right === undefined) {
+    return false;
+  }
+  if (right === null) {
+    return left < 0;
+  }
+  return left < right;
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(lt, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/lte.ts

@@ -0,0 +1,41 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Compares the two given values with <=
+
+  Example:
+
+  ```handlebars
+  {{lte age 17}}
+
+  {{! be true if `age` is <= 17}}
+  ```
+
+  @public
+  @method lte
+  @for Ember.Templates.helpers
+  @since 2.7.0
+*/
+function lte({ positional: { references } }: CapturedArguments) {
+  let left = references[0].value();
+  if (left === undefined || left === null) {
+    return false;
+  }
+  let right = references[1].value();
+  if (right === undefined) {
+    return false;
+  }
+  if (right === null) {
+    return left <= 0;
+  }
+  return left <= right;
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(lte, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/not-eq.ts

@@ -0,0 +1,30 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Compares the two given values with !==
+
+  Example:
+
+  ```handlebars
+  {{not-eq type "button"}}
+
+  {{! be true if `type` !== "button"}}
+  ```
+
+  @public
+  @method not-eq
+  @for Ember.Templates.helpers
+  @since 3.7.0
+*/
+function notEq({ positional: { references } }: CapturedArguments) {
+  return references[0].value() !== references[1].value();
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(notEq, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/not.ts

@@ -0,0 +1,30 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Compares the two given values with ===
+
+  Example:
+
+  ```handlebars
+  {{not disabled}}
+
+  {{! be true if `disabled` is false}}
+  ```
+
+  @public
+  @method not
+  @for Ember.Templates.helpers
+  @since 3.7.0
+*/
+function not({ positional: { references } }: CapturedArguments) {
+  return !references[0].value();
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(not, args.capture());
+}

packages/@ember/-internals/glimmer/lib/helpers/or.ts

@@ -0,0 +1,37 @@
+import { Arguments, CapturedArguments, VM } from '@glimmer/runtime';
+import { InternalHelperReference } from '../utils/references';
+
+/**
+@module ember
+*/
+
+/**
+  Evaluates the given arguments with || in short-circuit
+
+  Example:
+
+  ```handlebars
+  {{or isAdmin isAuthor}}
+
+  {{! be validData either `isAdmin` or `isAuthor` are truthy}}
+  ```
+
+  @public
+  @method or
+  @for Ember.Templates.helpers
+  @since 3.7.0
+*/
+function or({ positional: { references } }: CapturedArguments) {
+  let last: any = false;
+  for (let i = 0; i < references.length; i++) {
+    last = references[i].value();
+    if (last) {
+      return last;
+    }
+  }
+  return last;
+}
+
+export default function(_vm: VM, args: Arguments) {
+  return new InternalHelperReference(or, args.capture());
+}

packages/@ember/-internals/glimmer/lib/resolver.ts

@@ -3,6 +3,7 @@ import { ENV } from '@ember/-internals/environment';
 import { LookupOptions, Owner, setOwner } from '@ember/-internals/owner';
 import { lookupComponent, lookupPartial, OwnedTemplateMeta } from '@ember/-internals/views';
 import {
+  EMBER_BASIC_TEMPLATE_HELPERS,
   EMBER_MODULE_UNIFICATION,
   GLIMMER_CUSTOM_COMPONENT_MANAGER,
   GLIMMER_MODIFIER_MANAGER,
@@ -29,14 +30,23 @@ 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 and } from './helpers/and';
 import { default as array } from './helpers/array';
 import { default as concat } from './helpers/concat';
 import { default as eachIn } from './helpers/each-in';
+import { default as eq } from './helpers/eq';
 import { default as get } from './helpers/get';
+import { default as gt } from './helpers/gt';
+import { default as gte } from './helpers/gte';
 import { default as hash } from './helpers/hash';
 import { inlineIf, inlineUnless } from './helpers/if-unless';
 import { default as log } from './helpers/log';
+import { default as lt } from './helpers/lt';
+import { default as lte } from './helpers/lte';
 import { default as mut } from './helpers/mut';
+import { default as not } from './helpers/not';
+import { default as notEq } from './helpers/not-eq';
+import { default as or } from './helpers/or';
 import { default as queryParams } from './helpers/query-param';
 import { default as readonly } from './helpers/readonly';
 import { default as unbound } from './helpers/unbound';
@@ -84,6 +94,18 @@ const BUILTINS_HELPERS = {
   '-outlet': outletHelper,
 };
 
+if (EMBER_BASIC_TEMPLATE_HELPERS) {
+  BUILTINS_HELPERS['and'] = and;
+  BUILTINS_HELPERS['eq'] = eq;
+  BUILTINS_HELPERS['gt'] = gt;
+  BUILTINS_HELPERS['gte'] = gte;
+  BUILTINS_HELPERS['lt'] = lt;
+  BUILTINS_HELPERS['lte'] = lte;
+  BUILTINS_HELPERS['not'] = not;
+  BUILTINS_HELPERS['not-eq'] = notEq;
+  BUILTINS_HELPERS['or'] = or;
+}
+
 if (DEBUG) {
   BUILTINS_HELPERS['-assert-implicit-component-helper-argument'] = componentAssertionHelper;
 }