terraform-generator/dist/utils/Util.js

Generate Terraform configurations with Node.js.

"use strict";
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _a, _Util_escapeChars;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Util = void 0;
const blocks_1 = require("../blocks");
const _1 = require(".");
class Util {
    static escape(str) {
        __classPrivateFieldGet(this, _a, "f", _Util_escapeChars).forEach(char => {
            str = str.replaceAll(char[0], char[1]);
        });
        return str;
    }
    static unescape(str) {
        __classPrivateFieldGet(this, _a, "f", _Util_escapeChars).slice().reverse().forEach(char => {
            str = str.replaceAll(char[1], char[0]);
        });
        return str;
    }
    static argumentsToString(args) {
        let str = '';
        for (const key in args) {
            str += this.argumentToString(key, args[key]);
        }
        return str;
    }
    static isObjectArgument(value) {
        if (['string', 'number', 'boolean'].indexOf(typeof value) >= 0 || value instanceof _1.TerraformElement) {
            return false;
        }
        if (typeof value === 'object') {
            return true;
        }
        throw new Error(`Invalid value: ${value}`);
    }
    static argumentToString(key, value) {
        try {
            if (value == null) {
                return '';
            }
            if (!key.match(_1.IDENTIFIER_REGEX)) {
                key = `"${key}"`;
            }
            let operator = ' = ';
            let isObjectArray = false;
            if (Array.isArray(value)) {
                if (value.length === 0 || this.isObjectArgument(value[0])) {
                    value = value.filter(element => element != null);
                    operator = ' ';
                    isObjectArray = true;
                }
            }
            else if (this.isObjectArgument(value)) {
                operator = ' ';
            }
            if (isObjectArray) {
                let str = '';
                if (Array.isArray(value)) {
                    value.forEach(element => {
                        str += `${key}${operator}${this.argumentValueToString(element)}\n`;
                    });
                }
                return str;
            }
            return `${key}${operator}${this.argumentValueToString(value)}\n`;
        }
        catch (err) {
            throw new Error(`Invalid value: ${key} = ${value}`);
        }
    }
    static argumentValueToString(value) {
        if (value == null) {
            return null;
        }
        if (value instanceof blocks_1.Block) {
            return value.asArgument().toTerraform();
        }
        if (value instanceof _1.TerraformElement) {
            return value.toTerraform();
        }
        if (['string', 'number', 'boolean'].indexOf(typeof value) >= 0) {
            return JSON.stringify(value);
        }
        if (typeof value === 'object') {
            if (Array.isArray(value)) {
                let str = '[\n';
                value.forEach((element, i) => {
                    str += `${this.argumentValueToString(element)}${i < value.length - 1 ? ',' : ''}\n`;
                });
                str += ']';
                return str;
            }
            let str = '{\n';
            for (const key in value) {
                str += this.argumentToString(key, value[key]);
            }
            str += '}';
            return str;
        }
        throw new Error(`Invalid value: ${value}`);
    }
    static inaccessibleMethod() {
        return new Error('Inaccessible method.');
    }
}
exports.Util = Util;
_a = Util;
_Util_escapeChars = { value: [
        ['"', '&tfgquot;']
    ] };