@tsed/cli-core 6.1.13 → 6.1.15

package/lib/esm/utils/hbs/comparison.js

@@ -1,431 +0,0 @@
-import { isNumber } from "@tsed/core";
-// @ts-ignore
-import util from "handlebars-utils";
-export const helpers = {};
-const contains = (val, obj, start) => {
-    if (val == null || obj == null || !isNumber(val.length)) {
-        return false;
-    }
-    return val.indexOf(obj, start) !== -1;
-};
-/**
- * Helper that renders the block if **both** of the given values
- * are truthy. If an inverse block is specified it will be rendered
- * when falsy. Works as a block helper, inline helper or
- * subexpression.
- *
- * ```handlebars
- * <!-- {great: true, magnificent: true} -->
- * {{#and great magnificent}}A{{else}}B{{/and}}
- * <!-- results in: 'A' -->
- * ```
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-helpers.and = (...args) => {
-    const len = args.length - 1;
-    const options = args[len];
-    let val = true;
-    for (let i = 0; i < len; i++) {
-        if (!args[i]) {
-            val = false;
-            break;
-        }
-    }
-    return util.value(val, this, options);
-};
-/**
- * Render a block when a comparison of the first and third
- * arguments returns true. The second argument is
- * the [arithemetic operator][operators] to use. You may also
- * optionally specify an inverse block to render when falsy.
- *
- * @param `a`
- * @param `operator` The operator to use. Operators must be enclosed in quotes: `">"`, `"="`, `"<="`, and so on.
- * @param `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or if specified the inverse block is rendered if falsey.
- * @block
- * @api public
- */
-helpers.compare = function (a, operator, b, options) {
-    /*eslint eqeqeq: 0*/
-    if (arguments.length < 4) {
-        throw new Error("handlebars Helper {{compare}} expects 4 arguments");
-    }
-    let result;
-    switch (operator) {
-        case "==":
-            result = a == b;
-            break;
-        case "===":
-            result = a === b;
-            break;
-        case "!=":
-            result = a != b;
-            break;
-        case "!==":
-            result = a !== b;
-            break;
-        case "<":
-            result = a < b;
-            break;
-        case ">":
-            result = a > b;
-            break;
-        case "<=":
-            result = a <= b;
-            break;
-        case ">=":
-            result = a >= b;
-            break;
-        case "typeof":
-            result = typeof a === b;
-            break;
-        default: {
-            throw new Error("helper {{compare}}: invalid operator: `" + operator + "`");
-        }
-    }
-    return util.value(result, this, options);
-};
-/**
- * Block helper that renders the block if `collection` has the
- * given `value`, using strict equality (`===`) for comparison,
- * otherwise the inverse block is rendered (if specified). If a
- * `startIndex` is specified and is negative, it is used as the
- * offset from the end of the collection.
- *
- * ```handlebars
- * <!-- array = ['a', 'b', 'c'] -->
- * {{#contains array "d"}}
- *   This will not be rendered.
- * {{else}}
- *   This will be rendered.
- * {{/contains}}
- * ```
- * @param {Array|Object|String} `collection` The collection to iterate over.
- * @param {any} `value` The value to check for.
- * @param {Number} `[startIndex=0]` Optionally define the starting index.
- * @param {Object} `options` Handlebars provided options object.
- * @block
- * @api public
- */
-helpers.contains = function (collection, value, startIndex, options) {
-    if (typeof startIndex === "object") {
-        options = startIndex;
-        startIndex = undefined;
-    }
-    const val = contains(collection, value, startIndex);
-    return util.value(val, this, options);
-};
-/**
- * Returns the first value that is not undefined, otherwise the "default" value is returned.
- *
- * @param {any} `value`
- * @param {any} `defaultValue`
- * @return {String}
- * @alias .or
- * @api public
- */
-helpers.default = (...args) => {
-    for (let i = 0; i < args.length - 1; i++) {
-        if (args[i] != null)
-            return args[i];
-    }
-    return "";
-};
-/**
- * Block helper that renders a block if `a` is **equal to** `b`.
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @alias is
- * @block
- * @api public
- */
-helpers.eq = function (a, b, options) {
-    if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a === b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **greater than** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.gt = function (a, b, options) {
-    if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a > b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **greater than or
- * equal to** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.gte = function (a, b, options) {
-    if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a >= b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **equal to** `b`.
- * If an inverse block is specified it will be rendered when falsy.
- * Similar to [eq](#eq) but does not do strict equality.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-helpers.is = function (a, b, options) {
-    if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a == b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **not equal to** `b`.
- * If an inverse block is specified it will be rendered when falsy.
- * Similar to [unlessEq](#unlesseq) but does not use strict equality for
- * comparisons.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-helpers.isnt = function (a, b, options) {
-    if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a != b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **less than** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {Object} `context`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.lt = function (a, b, options) {
-    if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a < b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **less than or
- * equal to** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {Sring} `a`
- * @param {Sring} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.lte = function (a, b, options) {
-    if (arguments.length === 2) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a <= b, this, options);
-};
-/**
- * Block helper that renders a block if **neither of** the given values
- * are truthy. If an inverse block is specified it will be rendered
- * when falsy.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param `options` Handlebars options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.neither = function (a, b, options) {
-    return util.value(!a && !b, this, options);
-};
-/**
- * Returns true if `val` is falsey. Works as a block or inline helper.
- *
- * @param {String} `val`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-helpers.not = function (val, options) {
-    return util.value(!val, this, options);
-};
-/**
- * Block helper that renders a block if **any of** the given values
- * is truthy. If an inverse block is specified it will be rendered
- * when falsy.
- *
- * ```handlebars
- * {{#or a b c}}
- *   If any value is true this will be rendered.
- * {{/or}}
- * ```
- *
- * @param {...any} `arguments` Variable number of arguments
- * @param {Object} `options` Handlebars options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.or = function (...args) {
-    const len = args.length - 1;
-    const options = args[len];
-    let val = false;
-    for (let i = 0; i < len; i++) {
-        if (args[i]) {
-            val = true;
-            break;
-        }
-    }
-    return util.value(val, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is equal to `b`**.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Inverse block by default, or block if falsey.
- * @block
- * @api public
- */
-helpers.unlessEq = function (a, b, options) {
-    if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a !== b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is greater than `b`**.
- *
- * @param {Object} `a` The default value
- * @param {Object} `b` The value to compare
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Inverse block by default, or block if falsey.
- * @block
- * @api public
- */
-helpers.unlessGt = function (a, b, options) {
-    if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a <= b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is less than `b`**.
- *
- * @param {Object} `a` The default value
- * @param {Object} `b` The value to compare
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.unlessLt = function (a, b, options) {
-    if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a >= b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is greater than or equal to `b`**.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.unlessGteq = function (a, b, options) {
-    if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a < b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is less than or equal to `b`**.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-helpers.unlessLteq = function (a, b, options) {
-    if (util.isOptions(b)) {
-        options = b;
-        b = options.hash.compare;
-    }
-    return util.value(a > b, this, options);
-};

package/lib/esm/utils/hbs/index.js

@@ -1,11 +0,0 @@
-import handlebars from "handlebars";
-import { helpers as array } from "./array.js";
-import { helpers as collection } from "./collection.js";
-import { helpers as comparison } from "./comparison.js";
-import { helpers as object } from "./object.js";
-import { helpers as switchHelpers } from "./switch.js";
-handlebars.registerHelper(array);
-handlebars.registerHelper(object);
-handlebars.registerHelper(collection);
-handlebars.registerHelper(comparison);
-handlebars.registerHelper(switchHelpers);

package/lib/esm/utils/hbs/object.js

@@ -1,236 +0,0 @@
-import { getValue, isNumber, isObject } from "@tsed/core";
-// @ts-ignore
-import createFrame from "create-frame";
-// @ts-ignore
-import util from "handlebars-utils";
-import { helpers as array } from "./array.js";
-const hasOwn = Object.hasOwnProperty;
-export const helpers = {};
-/**
- * Extend the context with the properties of other objects.
- * A shallow merge is performed to avoid mutating the context.
- *
- * @param {Object} `objects` One or more objects to extend.
- * @return {Object}
- * @api public
- */
-helpers.extend = function ( /*objects*/) {
-    const args = [].slice.call(arguments);
-    let opts = {};
-    if (util.isOptions(args[args.length - 1])) {
-        // remove handlebars options object
-        opts = args.pop().hash;
-        // re-add handlebars options.hash object
-        args.push(opts);
-    }
-    const context = {};
-    for (let i = 0; i < args.length; i++) {
-        const obj = args[i];
-        if (util.isObject(obj)) {
-            const keys = Object.keys(obj);
-            for (let j = 0; j < keys.length; j++) {
-                const key = keys[j];
-                context[key] = obj[key];
-            }
-        }
-    }
-    return context;
-};
-/**
- * Block helper that iterates over the properties of
- * an object, exposing each key and value on the context.
- *
- * @param {Object} `context`
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-helpers.forIn = function (obj, options) {
-    if (!util.isOptions(options)) {
-        return obj.inverse(this);
-    }
-    const data = createFrame(options, options.hash);
-    let result = "";
-    for (const key in obj) {
-        data.key = key;
-        result += options.fn(obj[key], { data: data });
-    }
-    return result;
-};
-/**
- * Block helper that iterates over the **own** properties of
- * an object, exposing each key and value on the context.
- *
- * @param {Object} `obj` The object to iterate over.
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-helpers.forOwn = function (obj, options) {
-    if (!util.isOptions(options)) {
-        return obj.inverse(this);
-    }
-    const data = createFrame(options, options.hash);
-    let result = "";
-    for (const key in obj) {
-        if (obj.hasOwnProperty(key)) {
-            data.key = key;
-            result += options.fn(obj[key], { data: data });
-        }
-    }
-    return result;
-};
-/**
- * Take arguments and, if they are string or number, convert them to a dot-delineated object property path.
- *
- * @param {String|Number} `prop` The property segments to assemble (can be multiple).
- * @return {String}
- * @api public
- */
-helpers.toPath = function (...args) {
-    const prop = [];
-    for (let i = 0; i < arguments.length; i++) {
-        if (typeof args[i] === "string" || typeof args[i] === "number") {
-            prop.push(args[i]);
-        }
-    }
-    return prop.join(".");
-};
-/**
- * Use property paths (`a.b.c`) to get a value or nested value from
- * the context. Works as a regular helper or block helper.
- *
- * @param {String} `prop` The property to get, optionally using dot notation for nested properties.
- * @param {Object} `context` The context object
- * @param {Object} `options` The handlebars options object, if used as a block helper.
- * @return {String}
- * @block
- * @api public
- */
-helpers.get = function (prop, context, options) {
-    const val = getValue(context, prop);
-    if (options && options.fn) {
-        return val ? options.fn(val) : options.inverse(context);
-    }
-    return val;
-};
-/**
- * Return true if `key` is an own, enumerable property
- * of the given `context` object.
- *
- * ```handlebars
- * {{hasOwn context key}}
- * ```
- *
- * @param {String} `key`
- * @param {Object} `context` The context object.
- * @return {Boolean}
- * @api public
- */
-helpers.hasOwn = function (context, key) {
-    return hasOwn.call(context, key);
-};
-/**
- * Return true if `value` is an object.
- *
- * ```handlebars
- * {{isObject "foo"}}
- * //=> false
- * ```
- * @param {String} `value`
- * @return {Boolean}
- * @api public
- */
-helpers.isObject = isObject;
-/**
- * Parses the given string using `JSON.parse`.
- *
- * ```handlebars
- * <!-- string: '{"foo": "bar"}' -->
- * {{JSONparse string}}
- * <!-- results in: { foo: 'bar' } -->
- * ```
- * @param {String} `string` The string to parse
- * @contributor github.com/keeganstreet
- * @block
- * @api public
- */
-helpers.JSONparse = function (str) {
-    return JSON.parse(str);
-};
-/**
- * Stringify an object using `JSON.stringify`.
- *
- * ```handlebars
- * <!-- object: { foo: 'bar' } -->
- * {{JSONstringify object}}
- * <!-- results in: '{"foo": "bar"}' -->
- * ```
- * @param {Object} `obj` Object to stringify
- * @return {String}
- * @api public
- */
-helpers.JSONstringify = function (obj, indent) {
-    if (!isNumber(indent)) {
-        indent = 0;
-    }
-    return JSON.stringify(obj, null, indent);
-};
-/**
- * Deeply merge the properties of the given `objects` with the
- * context object.
- *
- * @param {Object} `object` The target object. Pass an empty object to shallow clone.
- * @param {Object} `objects`
- * @return {Object}
- * @api public
- */
-helpers.merge = function (...args1) {
-    const args = [].slice.call(args1);
-    let opts = {};
-    if (util.isOptions(args[args.length - 1])) {
-        // remove handlebars options object
-        opts = args.pop().hash;
-        // re-add options.hash
-        args.push(opts);
-    }
-    return Object.assign.apply(null, args);
-};
-/**
- * Alias for parseJSON. this will be
- * deprecated in a future release
- */
-helpers.parseJSON = helpers.JSONparse;
-/**
- * Pick properties from the context object.
- *
- * @param {Array|String} `properties` One or more properties to pick.
- * @param {Object} `context`
- * @param {Object} `options` Handlebars options object.
- * @return {Object} Returns an object with the picked values. If used as a block helper, the values are passed as context to the inner block. If no values are found, the context is passed to the inverse block.
- * @block
- * @api public
- */
-helpers.pick = function (props, context, options) {
-    const keys = array.arrayify(props);
-    const len = keys.length;
-    let i = -1;
-    let result = {};
-    while (++i < len) {
-        result = helpers.extend({}, result, getValue(context, keys[i]));
-    }
-    if (options.fn) {
-        if (Object.keys(result).length) {
-            return options.fn(result);
-        }
-        return options.inverse(context);
-    }
-    return result;
-};
-/**
- * Alias for JSONstringify. this will be
- * deprecated in a future release
- */
-helpers.stringify = helpers.JSONstringify;

package/lib/esm/utils/hbs/switch.js

@@ -1,10 +0,0 @@
-export const helpers = {};
-helpers.switch = function (value, options) {
-    this.switch_value = value;
-    return options.fn(this);
-};
-helpers.case = function (value, options) {
-    if (value == this.switch_value) {
-        return options.fn(this);
-    }
-};

package/lib/esm/utils/renderer/insertAfter.js

@@ -1,12 +0,0 @@
-export function insertAfter(fileContent, content, pattern) {
-    const lines = fileContent.split("\n");
-    const index = lines.findIndex((line) => {
-        return line.match(pattern);
-    });
-    const indent = lines[index].replace(lines[index].trim(), "");
-    lines[index] = lines[index] + "\n" + indent + content;
-    if (!["]", "}"].includes(lines[index + 1].trim()) && lines[index - 1].slice(-1) === ",") {
-        lines[index] += ",";
-    }
-    return lines.join("\n");
-}

package/lib/esm/utils/renderer/insertImport.js

@@ -1,11 +0,0 @@
-export function insertImport(fileContent, content) {
-    const lines = fileContent.split("\n");
-    const index = lines.findIndex((line) => {
-        if (line.startsWith("#!")) {
-            return false;
-        }
-        return !line.startsWith("import ");
-    });
-    lines[index] = content + "\n" + lines[index];
-    return lines.join("\n");
-}