at-builder 1.2.9 → 1.4.0

package/.claude/settings.local.json

@@ -1,15 +1,57 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npm run build:prod:*)",
-      "Bash(node:*)",
-      "Bash(npx tsc:*)",
-      "Bash(find:*)",
-      "Bash(rm:*)",
-      "Bash(npm ls:*)",
-      "Bash(ls:*)",
-      "Bash(npx eslint:*)"
-    ],
-    "deny": []
+      "Bash(npm run *)",
+      "Bash(npm install *)",
+      "Bash(/Users/upesenga/Documents/Projects/AT/at-builder/node_modules/.bin/tsc *)",
+      "Bash(node /Users/upesenga/Documents/Projects/AT/at-builder/bin/index.js)",
+      "Bash(node /Users/upesenga/Documents/Projects/AT/at-builder/bin/index.js --help)",
+      "Bash(node /Users/upesenga/Documents/Projects/AT/at-builder/bin/index.js sync --help)",
+      "Bash(node /Users/upesenga/Documents/Projects/AT/at-builder/bin/index.js deploy --help)",
+      "Bash(node --check /Users/upesenga/Documents/Projects/AT/at-builder/lib/at-deploy.js)",
+      "Bash(node --check /Users/upesenga/Documents/Projects/AT/at-builder/lib/at-sync.js)",
+      "Bash(node --check /Users/upesenga/Documents/Projects/AT/at-builder/webpack.config.js)",
+      "Bash(node *)",
+      "Bash(plop --help)",
+      "Bash(plop page *)",
+      "Bash(git rev-list *)",
+      "Bash(PATH=/dev/null node /Users/upesenga/Documents/Projects/AT/at-builder/bin/index.js install-extension)",
+      "Bash(git commit -m 'chore: drop broken postinstall reference, ignore test/ sandbox *)",
+      "Bash(git commit -m 'fix\\(plop\\): random windowFlagName per activity *)",
+      "Bash(git commit -m 'feat: doctor build.config validation, .env consolidation, install-extension command *)",
+      "Bash(git commit -m 'docs: document local-dev workflow \\(yarn link + npm pack\\) *)",
+      "Bash(git fetch *)",
+      "Bash(git check-ignore *)",
+      "Bash(git commit -m 'docs: move local-dev guide to standalone DEVELOPMENT.md *)",
+      "Bash(git add *)",
+      "Bash(atb --version)",
+      "Bash(atb --help)",
+      "Bash(tar tzf *)",
+      "Bash(npm ls *)",
+      "Bash(/usr/local/bin/atb --version)",
+      "Bash(grep -E \"\\(at-deploy|at-sync|index\\\\.js|\\\\.vsix|package\\\\.json\\)$\")",
+      "Bash(npm pack *)",
+      "Bash(tar xzf *)",
+      "Bash(tar xzOf at-builder-1.3.0.tgz package/package.json)",
+      "Bash(git commit -m '1.3.0 *)",
+      "Read(//usr/local/lib/node_modules/at-builder/bin/**)",
+      "Read(//Users/upesenga/.nvm/versions/node/v22.12.0/lib/node_modules/at-builder/bin/**)",
+      "Read(//usr/local/share/.config/yarn/link/**)",
+      "Bash(npm uninstall *)",
+      "Bash(/Users/upesenga/.nvm/versions/node/v22.12.0/bin/atb --version)",
+      "Bash(/Users/upesenga/.nvm/versions/node/v22.12.0/bin/atb --help)",
+      "Bash(/Users/upesenga/.nvm/versions/node/v22.12.0/lib/node_modules/at-builder/bin/index.js --version)",
+      "Bash(tar xzOf /Users/upesenga/Documents/Projects/AT/at-builder/at-builder-1.3.0.tgz package/package.json)",
+      "Bash(npm config *)",
+      "Bash(npm cache *)",
+      "Bash(git commit -m 'docs: capture two install-time gotchas hit during 1.3.0 verification *)",
+      "Bash(kill %1)",
+      "Bash(git commit -m 'fix\\(eslint-plugin\\): pass overrideConfigFile: true so build doesn'\\\\''t require consumer eslint.config.js *)",
+      "Bash(yarn global *)",
+      "Bash(ls -la \"$\\(yarn global bin\\)/atb\")",
+      "Bash(ls -la \"$\\(yarn global dir \\)/node_modules/at-builder\")",
+      "Bash(git commit -m 'fix: surface ESLint error detail and clean up atb deploy build-failure exit *)",
+      "Bash(git commit -m 'fix\\(webpack\\): emit correct `variation=` attribute on at-build.html script tag *)"
+    ]
   }
-}
+}

package/.plop/constants/index.js

@@ -1,11 +1,4 @@
-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

@@ -1,186 +1,277 @@
-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 { ACTION_ADD, TEMPLATE_DIR } = require("../constants");
+const { toPascalCase, generateUniqueId } = 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
+ * Builds the plop actions for `atb new`.
+ *
+ * Supported shapes:
+ *   AB single-page  → Activities/<test>/{VControl, Variation-N}/...
+ *   AB multi-page   → Activities/<test>/{VControl, Variation-N}/<Page>/...
+ *   XT single-page  → Activities/<test>/Experience-{A,B,...}/...
+ *   XT multi-page   → Activities/<test>/Experience-{A,B,...}/<Page>/...
+ *
+ * Always writes:
+ *   Activities/<test>/Vanalytics/analytics.js
+ *   Activities/<test>/shared/build.config.json (generated inline; matches the
+ *   schema consumed by lib/at-deploy.js and lib/at-sync.js)
+ *
+ * Side effect:
+ *   Updates ACTIVITY_FOLDER_NAME in the consumer's .env so subsequent
+ *   `atb build` / `atb deploy` find the right activity.
  */
 exports.actionHandler = (data) => {
-    let actions = [];
-    let fileName = '';
-    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 },
-        { 'global': true, 'path': `${testPath}/shared/build.config.json`, 'templateFile': `${TEMPLATE_DIR}/build.config.hbs`, variation }
-        ];
+    const { testName, variationName, activityType, pageNames } = data;
+
+    const isXT = activityType === 'xt';
+    const pages = pageNames
+        ? pageNames.split(',').map(p => p.trim()).filter(Boolean)
+        : [];
+    const isMultiPage = pages.length > 0;
+    const numberOfVariations = parseInt(variationName, 10);
+
+    if (!testName || Number.isNaN(numberOfVariations) || numberOfVariations < 1) {
+        console.error('❌ Invalid input: testName and a positive variation count are required.');
+        return [];
     }
 
-    // Get the activities path from environment variables (same approach as webpack config)
+    // ─── Resolve consumer paths ───
     const PWD = process.env.executionPath || process.cwd();
-    console.log(`📁 Using ACTIVITIES_BASE_FOLDER directory: ${process.env.executionPath}`);
     const ACTIVITIES_BASE_FOLDER = process.env.ACTIVITIES_BASE_FOLDER || 'Activities';
-    trackName = path.join(PWD, ACTIVITIES_BASE_FOLDER);
+    const activitiesRoot = path.join(PWD, ACTIVITIES_BASE_FOLDER);
+    const testPath = path.join(activitiesRoot, testName);
+
+    if (!fs.existsSync(activitiesRoot)) {
+        fs.mkdirSync(activitiesRoot, { recursive: true });
+        console.log(`📁 Created activities directory: ${activitiesRoot}`);
+    }
+    console.log(`📁 Activities directory: ${activitiesRoot}`);
+
+    const fileName = toPascalCase(testName);
+    // Random per-activity id avoids window-flag collisions when multiple
+    // at-builder activities end up loaded on the same page (deterministic
+    // names derived from testName would collide whenever two activities share
+    // a name stem). Frozen into analytics.hbs at scaffold time.
+    const windowFlagName = `atb_${generateUniqueId(15)}`;
+    const templateData = { fileName, windowFlagName };
 
-    // Log the activities path for debugging
-    console.log(`📁 Using activities directory: ${trackName}`);
+    const actions = [];
 
-    // Ensure the activities directory exists
-    if (!fs.existsSync(trackName)) {
-        fs.mkdirSync(trackName, { recursive: true });
-        console.log(`📁 Created activities directory: ${trackName}`);
+    // ─── Variation/experience folder generation ───
+    if (isXT) {
+        for (let i = 1; i <= numberOfVariations; i++) {
+            const expFolder = xtFolderName(i); // Experience-A, B, C...
+            if (isMultiPage) {
+                pages.forEach(page => addVariationFiles(actions, path.join(testPath, expFolder, page), templateData));
+            } else {
+                addVariationFiles(actions, path.join(testPath, expFolder), templateData);
+            }
+        }
+    } else if (isMultiPage) {
+        // AB multi-page: VControl + Variation-N, each with page subfolders
+        pages.forEach(page => addVariationFiles(actions, path.join(testPath, 'VControl', page), templateData));
+        for (let i = 1; i <= numberOfVariations; i++) {
+            pages.forEach(page => addVariationFiles(actions, path.join(testPath, `Variation-${i}`, page), templateData));
+        }
+    } else {
+        // AB single-page (legacy at-builder layout)
+        addVariationFiles(actions, path.join(testPath, 'VControl'), templateData);
+        for (let i = 1; i <= numberOfVariations; i++) {
+            addVariationFiles(actions, path.join(testPath, `Variation-${i}`), templateData);
+        }
     }
 
-    // Convert the name to camel case
-    fileName = toCamelCase(name);
+    // ─── Always: Vanalytics global file ───
+    actions.push({
+        type: ACTION_ADD,
+        path: path.join(testPath, 'Vanalytics', 'analytics.js'),
+        templateFile: `${TEMPLATE_DIR}/analytics.hbs`,
+        data: templateData,
+        skipIfExists: true,
+        abortOnFail: true
+    });
 
-    // Get the number of variations from the user
-    numberOfVariations = parseInt(variationName);
+    // ─── shared/build.config.json (dynamic; matches deploy/sync schema) ───
+    const buildConfig = generateBuildConfig({ isXT, isMultiPage, pages, numberOfVariations, testName });
+    actions.push({
+        type: ACTION_ADD,
+        path: path.join(testPath, 'shared', 'build.config.json'),
+        template: JSON.stringify(buildConfig, null, 4) + '\n',
+        skipIfExists: true,
+        abortOnFail: true
+    });
 
-    let constantMappingFile = null;
+    // ─── Persist ACTIVITY_FOLDER_NAME in consumer's .env ───
+    updateEnvFile(testName);
 
-    // If the user has provided track name and test name and variation name
-    if (trackName && testName && variationName) {
-        // Get the current year
-        testPath = trackName + `/${testName}`;
-        // Get the constant mapping
-        constantMappingFile = assignConstants();
-        // Convert the name to pascal case
-        fileName = toPascalCase(name);
+    // ─── Completion message ───
+    const shapeLabel = `${isXT ? 'XT' : 'AB'}${isMultiPage ? ' multi-page' : ''}`;
+    const countLabel = isXT
+        ? `${numberOfVariations} experience${numberOfVariations === 1 ? '' : 's'}`
+        : `${numberOfVariations} variation${numberOfVariations === 1 ? '' : 's'} + control`;
+    console.log(`\n🎉 Activity "${testName}" created successfully!`);
+    console.log(`📁 Location: ${testPath}`);
+    console.log(`🧪 Shape:    ${shapeLabel} (${countLabel}${isMultiPage ? `, ${pages.length} page${pages.length === 1 ? '' : 's'}` : ''})`);
+    console.log(`🔧 ACTIVITY_FOLDER_NAME updated in .env file`);
+    console.log(`\n💡 Next steps:`);
+    if (isMultiPage || isXT) {
+        console.log(`   1. Set activityInfo.id in shared/build.config.json once the AT activity exists`);
+        console.log(`   2. Run "atb sync" to pull pages/locationIds back from Adobe Target`);
+        console.log(`   3. Run "atb build" / "atb deploy"`);
+    } else {
+        console.log(`   1. Run "atb build" to build your activity`);
+        console.log(`   2. Run "atb deploy" once activityInfo.id is set in shared/build.config.json`);
     }
 
-    // Create actions for the global files
-    createActionObject(true);
-
+    return actions;
+};
 
+// ─── Helpers ──────────────────────────────────────────────────────────────
 
-    // Loop through the number of variations provided by the user
-    let i = 1;
+function xtFolderName(i) {
+    // Experience-A, B, C, ... For i > 26, falls back to Experience-AA, AB, ... (rare).
+    if (i <= 26) return `Experience-${String.fromCharCode(64 + i)}`;
+    const first = String.fromCharCode(64 + Math.floor((i - 1) / 26));
+    const second = String.fromCharCode(65 + ((i - 1) % 26));
+    return `Experience-${first}${second}`;
+}
 
-    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++;
+function addVariationFiles(actions, folderAbs, templateData) {
+    const files = [
+        { rel: 'index.js', tpl: 'index.hbs' },
+        { rel: path.join('scripts', 'app.js'), tpl: 'component.cb.hbs' },
+        { rel: path.join('css', 'style.scss'), tpl: 'style.hbs' },
+        { rel: path.join('constants', 'index.js'), tpl: 'constants.hbs' }
+    ];
+    for (const f of files) {
+        actions.push({
+            type: ACTION_ADD,
+            path: path.join(folderAbs, f.rel),
+            templateFile: `${TEMPLATE_DIR}/${f.tpl}`,
+            data: templateData,
+            skipIfExists: true,
+            abortOnFail: true
+        });
     }
-    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
+}
+
+/**
+ * Build the build.config.json contents for a fresh activity.
+ *
+ * Schema matches what lib/at-deploy.js / lib/at-sync.js read:
+ *   - activityType : "ab" | "xt"
+ *   - pages        : { <pageName>: <locationLocalId placeholder> }   (multi-page only)
+ *   - variations   : { <folderName>: <ATExperienceName> }            (single-page)
+ *                  | { <folderName>: { experienceName, pages: { <pageName>: "<folder>/<page>" } } } (multi-page)
+ *   - buildFolders : extra top-level folders webpack should also bundle
+ *
+ * `id` and locationLocalIds are placeholders — `atb sync` populates them
+ * from the Adobe Target activity once it exists.
+ */
+function generateBuildConfig({ isXT, isMultiPage, pages, numberOfVariations, testName }) {
+    const config = {
+        activityInfo: {
+            id: null,
+            activityType: isXT ? 'xt' : 'ab',
+            name: testName
+        }
+    };
+
+    if (isMultiPage) {
+        config.activityInfo.pages = {};
+        pages.forEach((page, idx) => {
+            config.activityInfo.pages[page] = idx; // placeholder; atb sync overwrites
+        });
+
+        config.activityInfo.variations = {};
+
+        if (isXT) {
+            for (let i = 1; i <= numberOfVariations; i++) {
+                const expFolder = xtFolderName(i);
+                const expName = `Experience ${expFolder.split('-')[1]}`;
+                const expPages = {};
+                pages.forEach(page => { expPages[page] = `${expFolder}/${page}`; });
+                config.activityInfo.variations[expFolder] = {
+                    experienceName: expName,
+                    pages: expPages
                 };
-                if (item['templateFile']) {
-                    actionObj['templateFile'] = item['templateFile'];
-                } else {
-                    actionObj['template'] = item['template'];
-                }
-                actions.push(actionObj);
             }
-        });
+        } else {
+            // AB multi-page: VControl + Variation-N
+            const controlPages = {};
+            pages.forEach(page => { controlPages[page] = `VControl/${page}`; });
+            config.activityInfo.variations['VControl'] = {
+                experienceName: 'Control',
+                pages: controlPages
+            };
+            for (let i = 1; i <= numberOfVariations; i++) {
+                const folder = `Variation-${i}`;
+                const varPages = {};
+                pages.forEach(page => { varPages[page] = `${folder}/${page}`; });
+                config.activityInfo.variations[folder] = {
+                    experienceName: `Variation ${i}`,
+                    pages: varPages
+                };
+            }
+        }
+    } else {
+        // Single-page: simple { folder: ATExperienceName } map
+        config.activityInfo.variations = {};
+        if (isXT) {
+            for (let i = 1; i <= numberOfVariations; i++) {
+                const expFolder = xtFolderName(i);
+                const expName = `Experience ${expFolder.split('-')[1]}`;
+                config.activityInfo.variations[expFolder] = expName;
+            }
+        } else {
+            config.activityInfo.variations['VControl'] = 'Control';
+            for (let i = 1; i <= numberOfVariations; i++) {
+                config.activityInfo.variations[`Variation-${i}`] = `Variation ${i}`;
+            }
+        }
     }
 
-    // Update .env file with the new activity name
-    updateEnvFile(testName);
-    
-    // Show completion message
-    console.log(`\n🎉 Activity "${testName}" created successfully!`);
-    console.log(`📁 Location: ${testPath}`);
-    console.log(`📋 Number of variations: ${numberOfVariations}`);
-    console.log(`🔧 ACTIVITY_FOLDER_NAME updated in .env file`);
-    console.log(`\n💡 Run "atb build" to build your activity`);
-    console.log(`💡 Run "atb doctor" to check your configuration`);
-
-    // Return the actions
-    return actions;
+    config.activityInfo.buildFolders = ['Vanalytics'];
+    return config;
 }
 
 /**
- * Updates the .env file with the new activity folder name
- * @param {string} activityName - The name of the activity to set in ACTIVITY_FOLDER_NAME
+ * Updates the consumer's .env file with the new activity folder name so
+ * subsequent `atb build`/`atb deploy` find it without manual editing.
  */
 function updateEnvFile(activityName) {
     const PWD = process.env.executionPath || process.cwd();
     const envPath = path.join(PWD, '.env');
-    
+
     if (!fs.existsSync(envPath)) {
         console.log('⚠️ .env file not found, skipping ACTIVITY_FOLDER_NAME update');
         console.log('💡 Run "atb init" to create .env file');
         return;
     }
-    
     if (!activityName || activityName.trim() === '') {
         console.log('⚠️ Activity name is empty, skipping .env update');
         return;
     }
-    
+
     try {
-        // Read the current .env file
         let envContent = fs.readFileSync(envPath, 'utf8');
-        
-        // Clean activity name (remove quotes if present)
         const cleanActivityName = activityName.trim().replace(/^["']|["']$/g, '');
-        
-        // Update or add ACTIVITY_FOLDER_NAME
         const activityFolderRegex = /^ACTIVITY_FOLDER_NAME=.*$/m;
         const newLine = `ACTIVITY_FOLDER_NAME="${cleanActivityName}"`;
-        
+
         if (activityFolderRegex.test(envContent)) {
-            // Update existing line
             envContent = envContent.replace(activityFolderRegex, newLine);
             console.log(`✅ Updated ACTIVITY_FOLDER_NAME to "${cleanActivityName}" in .env file`);
         } else {
-            // Add new line if it doesn't exist, ensure it ends with newline
-            if (!envContent.endsWith('\n')) {
-                envContent += '\n';
-            }
-            envContent += newLine;
+            if (!envContent.endsWith('\n')) envContent += '\n';
+            envContent += newLine + '\n';
             console.log(`✅ Added ACTIVITY_FOLDER_NAME="${cleanActivityName}" to .env file`);
         }
-        
-        // Write the updated content back to .env file
+
         fs.writeFileSync(envPath, envContent, 'utf8');
-        
     } catch (error) {
         console.error(`❌ Error updating .env file: ${error.message}`);
         console.log('💡 You may need to manually set ACTIVITY_FOLDER_NAME in your .env file');
     }
 }
-

package/.plop/generators/prompts.js

@@ -1,31 +1,63 @@
-const { PROMPT_TYPE_INPUT } = require("../constants");
+const kleur = require('kleur');
+const { PROMPT_TYPE_INPUT, PROMPT_TYPE_LIST } = require('../constants');
 
-function promptToChooseTrack(inquirer, answers = {}) {
+/**
+ * Prompts for `atb new`.
+ *
+ * Collects:
+ *   - activityType  : "ab" | "xt"
+ *   - testName      : activity folder name (e.g. "TEST-1234 ...")
+ *   - variationName : count — interpreted as treatment variations (AB) or experiences (XT)
+ *   - pageNames     : optional comma-separated page list. Empty → single-page.
+ */
+const ask = (label, hint) => hint
+    ? `${kleur.bold(label)} ${kleur.gray(`(${hint})`)}`
+    : kleur.bold(label);
 
-    const prompts = inquirer.prompt([
+const prompts = function (inquirer) {
+    console.log();
+    console.log(kleur.cyan().bold('  🧪 Create a new Adobe Target activity'));
+    console.log(kleur.gray('  ─ scaffolds variation folders + shared/build.config.json\n'));
+
+    return inquirer.prompt([
+        {
+            type: PROMPT_TYPE_LIST,
+            name: 'activityType',
+            prefix: kleur.cyan('›'),
+            message: ask('Activity type'),
+            choices: [
+                { name: `A/B Test ${kleur.gray('— control + variations')}`, value: 'ab' },
+                { name: `Experience Targeting (XT) ${kleur.gray('— audience-targeted experiences')}`, value: 'xt' }
+            ]
+        },
         {
             type: PROMPT_TYPE_INPUT,
             name: 'testName',
-            message: "Enter the test name"
+            prefix: kleur.cyan('›'),
+            message: ask('Activity name', 'folder name, e.g. TEST-1234 hero-banner'),
+            validate: (input) => input && input.trim()
+                ? true
+                : 'Activity name cannot be empty.'
         },
         {
             type: PROMPT_TYPE_INPUT,
             name: 'variationName',
-            message: "How many variations you want?"
+            prefix: kleur.cyan('›'),
+            message: (answers) => answers.activityType === 'xt'
+                ? ask('How many experiences?')
+                : ask('How many variations?', 'control is added automatically'),
+            validate: (input) => /^[1-9]\d*$/.test(String(input).trim())
+                ? true
+                : 'Enter a positive integer (1, 2, 3, ...).'
+        },
+        {
+            type: PROMPT_TYPE_INPUT,
+            name: 'pageNames',
+            prefix: kleur.cyan('›'),
+            message: ask('Page names', 'comma-separated for multi-page, blank for single-page'),
+            filter: (input) => (input || '').trim()
         }
     ]);
-    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;
+module.exports = prompts;

package/.plop/utils/index.js

@@ -1,10 +1,24 @@
 const _camelCase = require('lodash/camelCase');
 const _startCase = require('lodash/startCase');
 
-exports.toCamelCase = str => {
-  return _camelCase(str);
-};
-
 exports.toPascalCase = str => {
   return _startCase(_camelCase(str)).replace(/ /g, '');
-};
+};
+
+/**
+ * Generate a random alphanumeric id of the given length.
+ *
+ * Used for the `windowFlagName` baked into analytics.hbs — picking a fresh id
+ * per activity prevents window-flag collisions when two at-builder activities
+ * end up loaded on the same page (rare, but real). A deterministic name (e.g.
+ * derived from testName) would collide whenever two activities share a name
+ * stem.
+ */
+exports.generateUniqueId = (length = 15) => {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result;
+};

package/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "Slingshot.enableAutomaticCreationOfFilesWithFilenameClick": true,
+    "[handlebars]": {
+        "editor.formatOnSave": false
+    }
+}