at-builder 1.1.1 → 1.1.2

package/.eslintrc

@@ -0,0 +1,525 @@
+{
+    "parser": "@babel/eslint-parser",
+    "parserOptions": {
+        "ecmaVersion": "latest",
+        "sourceType": "module",
+        "es6": true
+    },
+    "env": {
+        "es2021": true,
+        "browser": true,
+        "jquery": true
+    },
+    "globals": {
+        "document": "readonly",
+        "navigator": "readonly",
+        "window": "readonly",
+        "utag_data": "readonly",
+        "utag": "readonly"
+    },
+    "ignorePatterns": [
+        "webpack.config.js",
+        "puppeteer.js",
+        "plopfile.js",
+        "build.js",
+        "babel.config.js",
+        "at-build-generator.js"
+    ],
+    "rules": {
+        "no-var": "warn",
+        "accessor-pairs": [
+            "error",
+            {
+                "setWithoutGet": true,
+                "enforceForClassMembers": true
+            }
+        ],
+        "array-bracket-spacing": [
+            "error",
+            "never"
+        ],
+        "array-callback-return": [
+            "error",
+            {
+                "allowImplicit": false,
+                "checkForEach": false
+            }
+        ],
+        "arrow-spacing": [
+            "error",
+            {
+                "before": true,
+                "after": true
+            }
+        ],
+        "block-spacing": [
+            "error",
+            "always"
+        ],
+        "brace-style": [
+            "error",
+            "1tbs",
+            {
+                "allowSingleLine": true
+            }
+        ],
+        "camelcase": [
+            "error",
+            {
+                "allow": [
+                    "^UNSAFE_"
+                ],
+                "properties": "never",
+                "ignoreGlobals": true
+            }
+        ],
+        "comma-dangle": [
+            "error",
+            {
+                "arrays": "never",
+                "objects": "never",
+                "imports": "never",
+                "exports": "never",
+                "functions": "never"
+            }
+        ],
+        "comma-spacing": [
+            "error",
+            {
+                "before": false,
+                "after": true
+            }
+        ],
+        "comma-style": [
+            "error",
+            "last"
+        ],
+        "computed-property-spacing": [
+            "error",
+            "never",
+            {
+                "enforceForClassMembers": true
+            }
+        ],
+        "constructor-super": "error",
+        "curly": [
+            "error",
+            "multi-line"
+        ],
+        "default-case-last": "error",
+        "dot-location": [
+            "error",
+            "property"
+        ],
+        "dot-notation": [
+            "error",
+            {
+                "allowKeywords": true
+            }
+        ],
+        "eol-last": "warn",
+        "eqeqeq": [
+            "error",
+            "always",
+            {
+                "null": "ignore"
+            }
+        ],
+        "func-call-spacing": [
+            "error",
+            "never"
+        ],
+        "generator-star-spacing": [
+            "error",
+            {
+                "before": true,
+                "after": true
+            }
+        ],
+        "indent": [
+            "error",
+            4
+        ],
+        "key-spacing": [
+            "error",
+            {
+                "beforeColon": false,
+                "afterColon": true
+            }
+        ],
+        "keyword-spacing": [
+            "error",
+            {
+                "before": true,
+                "after": true
+            }
+        ],
+        "lines-between-class-members": [
+            "error",
+            "always",
+            {
+                "exceptAfterSingleLine": true
+            }
+        ],
+        "multiline-ternary": [
+            "error",
+            "always-multiline"
+        ],
+        "new-cap": [
+            "error",
+            {
+                "newIsCap": true,
+                "capIsNew": false,
+                "properties": true
+            }
+        ],
+        "new-parens": "error",
+        "no-array-constructor": "error",
+        "no-async-promise-executor": "error",
+        "no-caller": "error",
+        "no-case-declarations": "error",
+        "no-class-assign": "error",
+        "no-compare-neg-zero": "error",
+        "no-cond-assign": "error",
+        "no-const-assign": "error",
+        "no-constant-condition": [
+            "error",
+            {
+                "checkLoops": false
+            }
+        ],
+        "no-control-regex": "error",
+        "no-debugger": "off",
+        "no-delete-var": "error",
+        "no-dupe-args": "error",
+        "no-dupe-class-members": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "error",
+        "no-useless-backreference": "error",
+        "no-empty": [
+            "error",
+            {
+                "allowEmptyCatch": true
+            }
+        ],
+        "no-empty-character-class": "error",
+        "no-empty-pattern": "error",
+        "no-eval": "error",
+        "no-ex-assign": "error",
+        "no-extend-native": "error",
+        "no-extra-bind": "error",
+        "no-extra-boolean-cast": "error",
+        "no-extra-parens": [
+            "error",
+            "functions"
+        ],
+        "no-fallthrough": "error",
+        "no-floating-decimal": "error",
+        "no-func-assign": "error",
+        "no-global-assign": "error",
+        "no-implied-eval": "error",
+        "no-import-assign": "error",
+        "no-invalid-regexp": "error",
+        "no-irregular-whitespace": "error",
+        "no-iterator": "error",
+        "no-labels": [
+            "error",
+            {
+                "allowLoop": false,
+                "allowSwitch": false
+            }
+        ],
+        "no-lone-blocks": "error",
+        "no-loss-of-precision": "error",
+        "no-misleading-character-class": "error",
+        "no-prototype-builtins": "error",
+        "no-useless-catch": "error",
+        "no-mixed-operators": [
+            "error",
+            {
+                "groups": [
+                    [
+                        "==",
+                        "!=",
+                        "===",
+                        "!==",
+                        ">",
+                        ">=",
+                        "<",
+                        "<="
+                    ],
+                    [
+                        "&&",
+                        "||"
+                    ],
+                    [
+                        "in",
+                        "instanceof"
+                    ]
+                ],
+                "allowSamePrecedence": true
+            }
+        ],
+        "no-mixed-spaces-and-tabs": "error",
+        "no-multi-spaces": "error",
+        "no-multi-str": "error",
+        "no-multiple-empty-lines": [
+            "error",
+            {
+                "max": 1,
+                "maxEOF": 0
+            }
+        ],
+        "no-new": "error",
+        "no-new-func": "error",
+        "no-new-object": "error",
+        "no-new-symbol": "error",
+        "no-new-wrappers": "error",
+        "no-obj-calls": "error",
+        "no-octal": "error",
+        "no-octal-escape": "error",
+        "no-proto": "error",
+        "no-redeclare": [
+            "error",
+            {
+                "builtinGlobals": false
+            }
+        ],
+        "no-regex-spaces": "error",
+        "no-return-assign": [
+            "error",
+            "except-parens"
+        ],
+        "no-self-assign": [
+            "error",
+            {
+                "props": true
+            }
+        ],
+        "no-self-compare": "error",
+        "no-sequences": "error",
+        "no-shadow-restricted-names": "error",
+        "no-sparse-arrays": "error",
+        "no-tabs": "error",
+        "no-template-curly-in-string": "error",
+        "no-this-before-super": "error",
+        "no-throw-literal": "error",
+        "no-trailing-spaces": "error",
+        "no-undef": "error",
+        "no-undef-init": "error",
+        "no-unexpected-multiline": "error",
+        "no-unmodified-loop-condition": "error",
+        "no-unneeded-ternary": [
+            "error",
+            {
+                "defaultAssignment": false
+            }
+        ],
+        "no-unreachable": "error",
+        "no-unreachable-loop": "error",
+        "no-unsafe-finally": "error",
+        "no-unsafe-negation": "error",
+        "no-unused-expressions": [
+            "error",
+            {
+                "allowShortCircuit": true,
+                "allowTernary": true,
+                "allowTaggedTemplates": true
+            }
+        ],
+        "no-unused-vars": [
+            "error",
+            {
+                "args": "none",
+                "caughtErrors": "none",
+                "ignoreRestSiblings": true,
+                "vars": "all"
+            }
+        ],
+        "no-use-before-define": [
+            "error",
+            {
+                "functions": false,
+                "classes": false,
+                "variables": false
+            }
+        ],
+        "no-useless-call": "error",
+        "no-useless-computed-key": "error",
+        "no-useless-constructor": "error",
+        "no-useless-escape": "error",
+        "no-useless-rename": "error",
+        "no-useless-return": "error",
+        "no-void": "error",
+        "no-whitespace-before-property": "error",
+        "no-with": "error",
+        "object-curly-newline": [
+            "error",
+            {
+                "multiline": true,
+                "consistent": true
+            }
+        ],
+        "object-curly-spacing": [
+            "error",
+            "always"
+        ],
+        "object-property-newline": [
+            "error",
+            {
+                "allowMultiplePropertiesPerLine": true
+            }
+        ],
+        "one-var": [
+            "error",
+            {
+                "initialized": "never"
+            }
+        ],
+        "operator-linebreak": [
+            "error",
+            "after",
+            {
+                "overrides": {
+                    "?": "before",
+                    ":": "before",
+                    "|>": "before"
+                }
+            }
+        ],
+        "padded-blocks": [
+            "error",
+            {
+                "blocks": "never",
+                "switches": "never",
+                "classes": "never"
+            }
+        ],
+        "prefer-const": [
+            "error",
+            {
+                "destructuring": "all"
+            }
+        ],
+        "prefer-promise-reject-errors": "error",
+        "prefer-regex-literals": [
+            "error",
+            {
+                "disallowRedundantWrapping": true
+            }
+        ],
+        "quote-props": [
+            "error",
+            "as-needed"
+        ],
+        "quotes": [
+            "error",
+            "single",
+            {
+                "avoidEscape": true,
+                "allowTemplateLiterals": false
+            }
+        ],
+        "rest-spread-spacing": [
+            "error",
+            "never"
+        ],
+        "semi-spacing": [
+            "error",
+            {
+                "before": false,
+                "after": true
+            }
+        ],
+        "space-before-blocks": [
+            "off",
+            "always"
+        ],
+        "space-before-function-paren": [
+            "off",
+            "always"
+        ],
+        "space-in-parens": [
+            "error",
+            "never"
+        ],
+        "space-infix-ops": "error",
+        "space-unary-ops": [
+            "error",
+            {
+                "words": true,
+                "nonwords": false
+            }
+        ],
+        "spaced-comment": [
+            "error",
+            "always",
+            {
+                "line": {
+                    "markers": [
+                        "*package",
+                        "!",
+                        "/",
+                        ",",
+                        "="
+                    ]
+                },
+                "block": {
+                    "balanced": true,
+                    "markers": [
+                        "*package",
+                        "!",
+                        ",",
+                        ":",
+                        "::",
+                        "flow-include"
+                    ],
+                    "exceptions": [
+                        "*"
+                    ]
+                }
+            }
+        ],
+        "symbol-description": "error",
+        "template-curly-spacing": [
+            "error",
+            "never"
+        ],
+        "template-tag-spacing": [
+            "error",
+            "never"
+        ],
+        "unicode-bom": [
+            "error",
+            "never"
+        ],
+        "use-isnan": [
+            "error",
+            {
+                "enforceForSwitchCase": true,
+                "enforceForIndexOf": true
+            }
+        ],
+        "valid-typeof": [
+            "error",
+            {
+                "requireStringLiterals": true
+            }
+        ],
+        "wrap-iife": [
+            "error",
+            "any",
+            {
+                "functionPrototypeMethods": true
+            }
+        ],
+        "yield-star-spacing": [
+            "error",
+            "both"
+        ],
+        "yoda": [
+            "error",
+            "never"
+        ]
+    }
+}

package/.plop/constants/index.js

@@ -0,0 +1,11 @@
+exports.path = require('path');
+exports.PATTERN_CLASS_BASED = 'Class-Based Component';
+exports.PATTERN_FUNCTIONAL = 'Functional Component';
+exports.TEMPLATE_DIR = '.plop/templates';
+exports.TEMPLATE_TYPE_SUFFIX_CLASS_BASED = 'cb';
+exports.TEMPLATE_TYPE_SUFFIX_FUNCTIONAL = 'func';
+exports.PROMPT_TYPE_LIST = 'list';
+exports.PROMPT_TYPE_INPUT = 'input';
+exports.ACTION_ADD = 'add';
+exports.type_script = 'script';
+exports.type_style = 'style';

package/.plop/generators/actions.js

@@ -0,0 +1,119 @@
+const { template } = require("lodash");
+const { ACTION_ADD, PATTERN_CLASS_BASED, PATTERN_FUNCTIONAL, TEMPLATE_DIR, TEMPLATE_TYPE_SUFFIX_CLASS_BASED, TEMPLATE_TYPE_SUFFIX_FUNCTIONAL } = require("../constants");
+const { toCamelCase, toPascalCase } = require("../utils");
+const path = require('path');
+
+const fs = require('fs');
+
+/**
+ * Action handler for plop
+ * @param {Object} data - Data that contains inputs from the user
+ * @returns {Array} - Array of actions that plop needs to perform
+ */
+exports.actionHandler = (data) => {
+    let { executionPath } = process.env;
+    let actions = [];
+    let fileName = '';
+    let componentType = '';
+    let folderName = '';
+    let testPath = '';
+    let numberOfVariations;
+    let { trackName, testName, variationName, name } = data;
+
+    /**
+     * Assigns constants to the files
+     * @param {String} variation - The name of the variation
+     * @returns {Array} - Array of objects with the path and template
+     */
+    function assignConstants(variation) {
+        return [{ 'global': false, 'path': `${folderName}/index.js`, 'templateFile': `${TEMPLATE_DIR}/index.hbs`, variation },
+        { 'global': true, 'path': `${testPath}/Vanalytics/analytics.js`, 'templateFile': `${TEMPLATE_DIR}/analytics.hbs`, variation },
+        { 'global': false, 'path': `${folderName}/constants/index.js`, 'templateFile': `${TEMPLATE_DIR}/constants.hbs`, variation },
+        { 'global': false, 'path': `${folderName}/scripts/app.js`, 'templateFile': `${TEMPLATE_DIR}/component.cb.hbs`, variation },
+        { 'global': false, 'path': `${folderName}/css/style.scss`, 'templateFile': `${TEMPLATE_DIR}/style.hbs`, variation }
+        ];
+    }
+
+    // Get the track path from the environment variable
+    trackName = executionPath + "/Activities";
+    // trackName = path.join(fs.readFileSync(path.join(process.cwd(), 'sample.txt'), { flag: 'r' }).toString(), 'Activities');
+
+    // Convert the name to camel case
+    fileName = toCamelCase(name);
+
+    // Get the number of variations from the user
+    numberOfVariations = parseInt(variationName);
+    
+    let constantMappingFile = null;
+
+    // If the user has provided track name and test name and variation name
+    if (trackName && testName && variationName) {
+        // Get the current year
+        let year = new Date().getFullYear();
+        // testPath = trackName + `/${year}/` + testName;
+        testPath = trackName + `/${testName}`;
+        // Get the constant mapping
+        constantMappingFile = assignConstants();
+        // Convert the name to pascal case
+        fileName = toPascalCase(name);
+        // Set the component type
+        componentType = TEMPLATE_TYPE_SUFFIX_CLASS_BASED;
+    }
+
+    // Create actions for the global files
+    createActionObject(true);
+
+    
+
+    // Loop through the number of variations provided by the user
+    let i = 1;
+    
+    do {
+        // Get the variation name
+        let variation = "Variation-" + i;
+        // Get the folder name
+        folderName = testPath + "/" + variation;
+        // Get the constant mapping
+        constantMappingFile = assignConstants(variation);
+        // Create actions for the variation files
+        createActionObject(false);
+        // Increment the loop counter
+        i++;
+    }
+    while (i <= numberOfVariations);
+
+    /**
+     * Creates an action object for plop
+     * @param {Boolean} isGlobalFile - If it is a global file or not
+     */
+    function createActionObject(isGlobalFile) {
+        constantMappingFile.forEach(item => {
+            if ((!item.global && !isGlobalFile) || (item.global && isGlobalFile)) {
+                let actionObj = {
+                    type: `${ACTION_ADD}`,
+                    path: item.path,
+                    data: {
+                        componentName: toPascalCase(name),
+                        variation: item.variation,
+                        fileName: fileName,
+                        windowFlagName: toPascalCase(testName)
+                    },
+                    skipIfExists: true,
+                    abortOnFail: true
+                };
+                if (item['templateFile']) {
+                    actionObj['templateFile'] = item['templateFile'];
+                } else {
+                    actionObj['template'] = item['template'];
+                }
+                actions.push(actionObj);
+            }
+        });
+    }
+
+    
+
+    // Return the actions
+    return actions;
+}
+

package/.plop/generators/components.js

@@ -0,0 +1,8 @@
+const { actionHandler } = require("./actions");
+const prompts = require("./prompts");
+
+module.exports = {
+  description: 'This will generate the basic files needed',
+  prompts: prompts,
+  actions: actionHandler
+};

package/.plop/generators/prompts.js

@@ -0,0 +1,31 @@
+const { PROMPT_TYPE_INPUT } = require("../constants");
+
+function promptToChooseTrack(inquirer, answers = {}) {
+
+    const prompts = inquirer.prompt([
+        {
+            type: PROMPT_TYPE_INPUT,
+            name: 'testName',
+            message: "Enter the test name"
+        },
+        {
+            type: PROMPT_TYPE_INPUT,
+            name: 'variationName',
+            message: "How many variations you want?"
+        }
+    ]);
+    prompts.then((newAnswers) => {
+        Object.assign(newAnswers, answers);
+    });
+    return prompts;
+}
+
+
+const prompts = function (inquirer) {
+    const basePrompt = promptToChooseTrack(inquirer);
+    return basePrompt.then((answers) => {
+        return basePrompt;
+    });
+};
+
+module.exports = prompts;

package/.plop/index.js

@@ -0,0 +1,5 @@
+const components = require("./generators/components");
+
+module.exports = function (plop) {
+    plop.setGenerator('components', components );
+};