test('can be called using subexpression', function(assert) {
assert.expect(1);
this.registry.register('helper:get-format', helper(function() {
return 'L';
}));
this.set('date', date(0));
this.render(hbs`{{moment-format date (get-format 'global-format')}}`);
assert.equal(this.$().text(), '12/31/1969');
});
test('safe strings', async function(assert) {
assert.expect(2);
this.owner.register(
'helper:truncate',
helper(function(args) {
const [string, length] = args;
return htmlSafe(escapeExpression(string.slice(0, length)));
})
);
await render(hbs`<WrapUrls @text={{truncate "visit http://example.com" 16}} />`);
assert.dom(this.element).hasText('visit http://exa');
assert.deepEqual(this.getText('.wrapped-url'), ['http://exa']);
});
test("Framework Test - Ember set doesn't notify listeners when new value === the previous one", async function(assert) {
let renders = 0;
const countRenders = () => ++renders;
this.owner.register('helper:count-renders', buildHelper(countRenders));
this.set('model', { prop: 1 });
await this.render(hbs`
{{count-renders}}
<div id="output">{{model.prop}}</div>
`);
assert.equal(find('#output').textContent.trim(), '1', 'precondition - Ember gets the original value');
assert.equal(renders, 1, 'rendered once');
set(this.model, 'prop', 1);
assert.equal(find('#output').textContent.trim(), '1', 'New value is the same');
assert.equal(renders, 1, 'did not rerender');
});
test("AutosaveProxy doesn't notify listeners when value === the previous value", async function(assert) {
let renders = 0;
const countRenders = () => ++renders;
this.owner.register('helper:count-renders', buildHelper(countRenders));
let model = { prop: 1 };
this.set('proxy', AutosaveProxy.create(model));
await this.render(hbs`
{{count-renders}}
<div id="output">{{proxy.prop}}</div>
`);
assert.equal(find('#output').textContent.trim(), '1', 'precondition - Ember gets the original value');
assert.equal(renders, 1, 'rendered once');
set(this.proxy, 'prop', 1);
assert.equal(find('#output').textContent.trim(), '1', 'New value is the same');
assert.equal(renders, 1, 'did not rerender');
});
import { helper } from '@ember/component/helper';
export function runTime(params) {
var s = moment(params[0]);
var e = moment(params[1]);
var time = Math.round(e.diff(s) / 100) / 10;
if ( time ) {
if ( time > 60 ) {
time = Math.round(time);
}
return `${ time } sec`;
} else {
return '<span class="text-muted">-</span>'.htmlSafe();
}
}
export default helper(runTime);
import { helper as buildHelper } from '@ember/component/helper';
export default buildHelper(function([status]) {
switch(status) {
case 1:
return 'NOT CHECKED';
case 2:
return 'OK';
case 4:
return 'WARNING';
case 8:
return 'UNKNOWN';
case 16:
return 'CRITICAL';
}
return 'Unknown status '+status;
});
import { helper } from '@ember/component/helper';
export default helper(params => params);
const COMMAS_EVERY_THREE_DIGITS = /(\d)(?=(\d{3})+(?!\d))/g;
function applyFormatting(number) {
if (number.length == 0) {
return '';
} else {
return `${number.replace(COMMAS_EVERY_THREE_DIGITS, '$1,')}`;
}
}
/**
* Used to display a number in the format of 20,000.50
*
* - commas every 3 digits
* - dot as decimal separator when not trimming zero
* - fixed 2-decimal notation when not trimming zero
*
* In order to display zero decimals, provide a hash, consisting of
* `{ trimZero: false }` as the second parameter.
*
* @param {String} numberAsString The value to be formatted
* @param {Boolean} options.trimZero Indicates if zero decimals should be added
* @return {String} The value, formatted
*/
export function formatNumber([numberAsString], { trimZero = true } = {}) {
let number = prettyFloat(numberAsString, { trimZero });
return applyFormatting(number);
}
export default helper(formatNumber);
import Helper from '@ember/component/helper';
import { htmlSafe } from '@ember/string';
export function backgroundColor([ color ]) {
return htmlSafe(`background-color: ${color};`);
}
export default Helper.helper(backgroundColor);
import { helper } from '@ember/component/helper';
export function exp(params) {
return Math.exp(params[0]);
}
export default helper(exp);
label: 'Configuration',
routeParams: ['vault.cluster.settings.auth.configure.section', 'configuration'],
},
],
};
const TABS_FOR_SHOW = {};
export function tabsForAuthSection([methodType, sectionType = 'authSettings']) {
let tabs;
if (sectionType === 'authSettings') {
tabs = (TABS_FOR_SETTINGS[methodType] || []).slice();
tabs.push({
label: 'Method Options',
routeParams: ['vault.cluster.settings.auth.configure.section', 'options'],
});
return tabs;
}
tabs = (TABS_FOR_SHOW[methodType] || []).slice();
tabs.push({
label: 'Configuration',
routeParams: ['vault.cluster.access.method.section', 'configuration'],
});
return tabs;
}
export default buildHelper(tabsForAuthSection);
import { helper } from '@ember/component/helper';
/**
* Executes `Math.clz32` on the number passed to the helper.
*
* ```hbs
* {{clz32 a}}
* ```
*
* @param {number} number The number to pass to `Math.clz32`
* @return {number} The clz32 of the passed number
*/
export function clz32([number]) {
return Math.clz32(number);
}
export default helper(clz32);
import { helper } from '@ember/component/helper';
import { throttle as f } from '@ember/runloop';
export function throttle([callback, wait], { immediate=false }) {
return function(value) {
return f(null, callback, value, wait, immediate);
};
}
export default helper(throttle);
import { helper } from '@ember/component/helper';
export function subtract([a,b]/*, hash*/) {
return a-b;
}
export default helper(subtract);
import {helper} from '@ember/component/helper';
import {svgJar} from './svg-jar';
export function subscribersSortIcon([order, currentOrder, direction]) {
if (order === currentOrder) {
if (direction === 'asc') {
return svgJar('arrow-up', {class: 'ih2 mr2'});
} else {
return svgJar('arrow-down', {class: 'ih2 mr2'});
}
}
}
export default helper(subscribersSortIcon);
* `count / total` or `count / (count + complement)`
*/
export function formatPercentage(params, options = {}) {
const value = safeNumber(params[0]);
const complement = options.complement;
let ratio;
let total = options.total;
if (total !== undefined) {
total = safeNumber(total);
} else if (complement !== undefined) {
total = value + safeNumber(complement);
} else {
// Ensures that ratio is between 0 and 1 when neither total or complement are defined
total = value;
}
// Use zero instead of infinity when the divisor is zero
ratio = total ? value / total : 0;
return 0 < ratio && ratio < 0.01 ? '< 1%' : Math.round(ratio * 100) + '%';
}
// If a value is not a number, treat it as zero
function safeNumber(value) {
return isNaN(value) ? 0 : +value;
}
export default helper(formatPercentage);
import { helper } from '@ember/component/helper';
import rightTrim from 'consul-ui/utils/right-trim';
export default helper(function([str = '', search = ''], hash) {
return rightTrim(str, search);
});
import { helper } from '@ember/component/helper';
import { get } from '@ember/object';
/**
* Datacenters can be an array of datacenters.
* Anything that isn't an array means 'All', even an empty array.
*/
export function datacenters(params, hash = {}) {
const datacenters = get(params[0], 'Datacenters');
if (!Array.isArray(datacenters) || datacenters.length === 0) {
return [hash['global'] || 'All'];
}
return get(params[0], 'Datacenters');
}
export default helper(datacenters);
import { helper } from '@ember/component/helper';
export function min(params) {
return Math.min(...params);
}
export default helper(min);
// This software (Documize Community Edition) is licensed under
// GNU AGPL v3 http://www.gnu.org/licenses/agpl-3.0.en.html
//
// You can operate outside the AGPL restrictions by purchasing
// Documize Enterprise Edition and obtaining a commercial license
// by contacting <*****@*****.**>.
//
// https://documize.com
import { helper } from '@ember/component/helper';
export function formattedPrice(params) {
let pence = params[0];
if(!_.isNumber(pence)) {
return '$0'
}
let p = parseInt(pence);
if(p === 0) {
return '$0'
}
let a = pence / 100;
return `$` + a;
}
export default helper(formattedPrice);
import { helper } from '@ember/component/helper';
export function trunc(params) {
return Math.trunc(params[0]);
}
export default helper(trunc);
import { helper } from '@ember/component/helper';
export function notEq([v1, v2]/*, hash*/) {
return v1 !== v2;
}
export default helper(notEq);
import { helper } from '@ember/component/helper';
import { get } from '@ember/object';
const _isLegacy = function(token) {
// Empty Rules take priority over a Legacy: true
// in order to make this decision
const rules = get(token, 'Rules');
if (rules != null) {
return rules.trim() !== '';
}
const legacy = get(token, 'Legacy');
if (typeof legacy !== 'undefined') {
return legacy;
}
return false;
};
export function isLegacy(params, hash) {
const token = params[0];
// is array like (RecordManager isn't an array)
if (typeof token.length !== 'undefined') {
return token.find(function(item) {
return _isLegacy(item);
});
}
return _isLegacy(token);
}
export default helper(isLegacy);
import {htmlSafe as _htmlSafe} from '@ember/string';
import {helper} from '@ember/component/helper';
export function htmlSafe([str]/*, hash*/) {
return _htmlSafe(str || '');
}
export default helper(htmlSafe);
import { helper } from '@ember/component/helper';
export default helper(([truthy]) => !truthy);
import { helper } from '@ember/component/helper';
export function axisOptions([ position, width, height, x=0, y=0 ]) {
let w = position === 'right' ? width : 0;
let h = position === 'bottom' ? height : 0;
let translate = `translate(${w + x},${h + y})`;
let gridLength;
if (position === 'left' || position === 'right') {
gridLength = width;
} else {
gridLength = height;
}
return { gridLength, translate };
}
export default helper(axisOptions);
import { helper } from '@ember/component/helper';
export default helper(function([a, b]) {
return a === b;
});
import { helper } from '@ember/component/helper';
export function lessThan([a, b]/* , hash*/) {
return a < b;
}
export default helper(lessThan);
import { helper } from '@ember/component/helper';
/**
* Determines whether the text should be negative or positive colored, depending on whether the input is positive or
* negative
* @param {Float} float - numerical input to determine color
* @return {String} - 'up' or 'down', depending on the sign of the input
*/
export function calculateDirection(float) {
const direction = float < 0 ? 'down' : 'up';
return direction;
}
export default helper(calculateDirection);
import { helper as h } from "@ember/component/helper";
export const helper = h( params => params.some( value => value ) );