dceky 1.0.0-beta.6 → 1.0.3

package/start/helpers/print.ts

@@ -0,0 +1,155 @@
+/* eslint-disable no-console */
+
+/**
+ * Get the left buffer for a centered message
+ * @author Gabe Abrams
+ * @param message message to print
+ * @param padding amount of padding to add
+ * @returns number of chars in the buffer
+ */
+const leftBuffer = (message: string, padding: number): number => {
+  return (Math.floor(process.stdout.columns / 2) - padding - Math.ceil(message.length / 2));
+};
+
+/**
+ * Get the right buffer for a centered message
+ * @author Gabe Abrams
+ * @param message message to print
+ * @param padding amount of padding to add
+ * @returns number of chars in the buffer
+ */
+const rightBuffer = (message: string, padding: number): number => {
+  return (Math.ceil(process.stdout.columns / 2) - padding - Math.floor(message.length / 2));
+};
+
+/**
+ * Surround text with a border and spaces
+ * @author Gabe Abrams
+ * @param str text to print
+ * @param border single character to use as a border
+ * @returns text to print
+ */
+const surroundWithBuffer = (str: string, border: string): string => {
+  return (
+    border
+    + ' '.repeat(leftBuffer(str, border.length))
+    + str
+    + ' '.repeat(rightBuffer(str, border.length))
+    + border
+  );
+};
+
+/**
+ * Surround text with a character as the buffer
+ * @author Gabe Abrams
+ * @param str text to print
+ * @param char character to place as the buffer
+ * @returns text to print
+ */
+const surroundWithChars = (str: string, char: string): string => {
+  if (str.length > process.stdout.columns) {
+    return str;
+  }
+  if (str.length === process.stdout.columns - 1) {
+    return char + str;
+  }
+  if (str.length === process.stdout.columns - 2) {
+    return char + str + char;
+  }
+  return (
+    char.repeat(leftBuffer(str, 1))
+    + ' '
+    + str
+    + ' '
+    + char.repeat(rightBuffer(str, 1))
+  );
+};
+
+// Prompt instance
+let cachedPrompt: any;
+
+const print = {
+  /**
+   * Print a title
+   * @author Gabe Abrams
+   * @param str text to print
+   */
+  title: (str: string) => {
+    if (str.length > process.stdout.columns) {
+      return console.log(str);
+    }
+    console.log('\u2554' + '\u2550'.repeat(process.stdout.columns - 2) + '\u2557');
+    console.log(surroundWithBuffer(str, '\u2551'));
+    console.log('\u255A' + '\u2550'.repeat(process.stdout.columns - 2) + '\u255D');
+  },
+  /**
+   * Print a sub title (subheading)
+   * @author Gabe Abrams
+   * @param str text to print
+   */
+  subtitle: (str: string) => {
+    if (str.length > process.stdout.columns) {
+      return console.log(str);
+    }
+    console.log(surroundWithChars(str, '\u257C'));
+  },
+  /**
+   * Print centered text
+   * @author Gabe Abrams
+   * @param str text to print
+   */
+  centered: (str: string) => {
+    const lines = [];
+    let index = 0;
+    while (index < str.length) {
+      lines.push(str.substring(index, Math.min(index + process.stdout.columns, str.length)));
+      index += process.stdout.columns;
+    }
+    lines.forEach((line, lineIndex) => {
+      if (lineIndex !== lines.length - 1) {
+        // No need to center: fills whole line
+        console.log(line);
+      } else {
+        // This line needs to be centered
+        console.log(surroundWithChars(line, ' '));
+      }
+    });
+  },
+  /**
+   * Print a fatal error message
+   * @author Gabe Abrams
+   * @param err error message
+   */
+  fatalError: (err: string) => {
+    console.log('\n');
+    const errLine1 = err.substring(0, process.stdout.columns - 6);
+    const errLine2 = err.substring(process.stdout.columns - 6);
+    console.log('\u2554' + '\u2550'.repeat(3) + '\u2557 ');
+    console.log(`\u2551 ! \u2551 ${errLine1}`);
+    console.log('\u255A' + '\u2550'.repeat(3) + '\u255D ' + errLine2);
+    process.exit(0);
+  },
+  /**
+   * Save a copy of the prompt instance
+   * @author Gabe Abrams
+   * @param promptInstance instance of prompt-sync
+   */
+  savePrompt: (promptInstance: any) => {
+    cachedPrompt = promptInstance;
+  },
+  /**
+   * Ask the user to press enter before continuing
+   * @author Gabe Abrams
+   */
+  enterToContinue: () => {
+    const res = cachedPrompt(
+      surroundWithChars('enter to continue, ctrl+c to quit', '\u257C'),
+      true,
+    );
+    if (res === null) {
+      process.exit(0);
+    }
+  },
+};
+
+export default print;

package/start/helpers/prompt.ts

@@ -0,0 +1,23 @@
+import initPrompt from 'prompt-sync';
+import print from './print';
+
+const promptSync = initPrompt();
+
+/**
+ * Ask the user a question
+ * @param title title of the question
+ * @param notRequired true if question is not required
+ * @returns response
+ */
+const prompt = (title: string, notRequired?: boolean): string => {
+  const val = promptSync(title);
+  if (val === null || (!notRequired && !val)) {
+    process.exit(0);
+  }
+  return val;
+};
+
+// Save the prompt for use later
+print.savePrompt(prompt);
+
+export default prompt;

package/start/helpers/showChooser.ts

@@ -0,0 +1,140 @@
+/* eslint-disable no-console */
+import clear from 'clear';
+
+// Import shared helpers
+import print from './print';
+import prompt from './prompt';
+import parseCommaSeparated from './parseCommaSeparated';
+
+// Import shared types
+import ChooserOption from '../types/ChooserOption';
+
+/**
+ * Show a chooser between many options
+ * @author Gabe Abrams
+ * @author Yuen Ler Chow
+ * @param opts object of arguments
+ * @param opts.question the question to ask
+ * @param opts.options list of options to choose from
+ * @param opts.title main title to show above the choices
+ * @param opts.dontClear if true, don't clear the console before
+ * @param opts.allowMulti if true, allow multiple selections (comma-separated)
+ * @returns array of chosen option(s)
+ */
+const showChooser = (
+  opts: {
+    question: string,
+    options: ChooserOption[],
+    title?: string,
+    dontClear?: boolean,
+    allowMulti?: boolean,
+  },
+): ChooserOption[] => {
+  const {
+    question,
+    options,
+    title,
+    dontClear,
+    allowMulti = false,
+  } = opts;
+
+  // Helper to re-display the chooser after an invalid selection
+  const retryWithMessage = (message: string) => {
+    clear();
+    print.title('Invalid Choice');
+    console.log(message);
+    console.log('');
+    print.enterToContinue();
+    return showChooser({
+      question,
+      options,
+      title,
+      dontClear,
+      allowMulti,
+    });
+  };
+
+  // Print the header
+  if (!dontClear) {
+    clear();
+  }
+  if (title) {
+    print.title(title);
+    console.log('');
+  }
+  print.subtitle(question);
+
+  // Make sure all options have tags
+  let nextNumber = 1;
+  const optionsWithTags = options.map((option) => {
+    // Get/generate a tag
+    let { tag } = option;
+    if (!tag) {
+      tag = String(nextNumber);
+      nextNumber += 1;
+    }
+
+    // Return complete option
+    return {
+      ...option,
+      tag,
+    };
+  });
+
+  // Print options
+  optionsWithTags.forEach((option) => {
+    console.log(`${option.tag} - ${option.description}`);
+  });
+
+  // Ask user to choose
+  const response = prompt('> ').trim();
+
+  // Always parse as comma-separated (treat all inputs with multi-select logic)
+  const selectedTags = parseCommaSeparated(response);
+
+  // Fail fast if multi-select is not allowed but multiple selections were made
+  if (!allowMulti && selectedTags.length > 1) {
+    return retryWithMessage(
+      'Multiple selections are not allowed. Please select only one option.',
+    );
+  }
+
+  // Find matching options
+  const selected: Array<{ description: string; tag: string; index: number }> = [];
+  const invalidTags: string[] = [];
+
+  selectedTags.forEach((tag) => {
+    const lowerTag = tag.toLowerCase();
+    let found = false;
+    optionsWithTags.forEach((opt, idx) => {
+      if (opt.tag.toLowerCase() === lowerTag) {
+        selected.push({
+          description: opt.description,
+          tag: opt.tag,
+          index: idx,
+        });
+        found = true;
+      }
+    });
+
+    if (!found) {
+      invalidTags.push(tag);
+    }
+  });
+
+  // Handle invalid tags
+  if (invalidTags.length > 0) {
+    return retryWithMessage(
+      `The following selections are not valid: ${invalidTags.join(', ')}`,
+    );
+  }
+
+  // Handle no selections
+  if (selected.length === 0) {
+    return retryWithMessage('No valid selections made.');
+  }
+
+  return selected;
+};
+
+export default showChooser;

package/start/helpers/validateBrowsers.ts

@@ -0,0 +1,35 @@
+/* eslint-disable no-console */
+import AVAILABLE_BROWSERS from '../constants/AVAILABLE_BROWSERS';
+
+/**
+ * Validate browsers (supports multiple)
+ * @author Yuen Ler Chow
+ * @param browserNames array of browser names to validate
+ * @returns array of valid browser names (lowercased)
+ */
+const validateBrowsers = (browserNames: string[]): string[] => {
+  const valid: string[] = [];
+  const invalid: string[] = [];
+
+  // Convert all browser names to lowercase for comparison
+  const lowercaseBrowserNames = browserNames.map((browser) => { return browser.toLowerCase(); });
+
+  // Validate each browser
+  lowercaseBrowserNames.forEach((browser) => {
+    if (AVAILABLE_BROWSERS.some((b) => { return b.name.toLowerCase() === browser.toLowerCase(); })) {
+      valid.push(browser);
+    } else {
+      invalid.push(browser);
+    }
+  });
+
+  // If there are invalid browsers, log error and exit
+  if (invalid.length > 0) {
+    console.error(`Browser(s) invalid: ${invalid.join(', ')}. Available browsers: ${AVAILABLE_BROWSERS.join(', ')}`);
+    process.exit(1);
+  }
+
+  return valid;
+};
+
+export default validateBrowsers;

package/start/index.ts

@@ -0,0 +1,164 @@
+/* eslint-disable no-console */
+/**
+ * Checks arguments and environment variables (for PROFILE, BROWSER, and HEADLESS),
+ * asks user for missing selections, and launches Cypress
+ * @author Gardenia Liu
+ * @author Yuen Ler Chow
+ */
+
+// Import libs
+import fs from 'fs';
+import path from 'path';
+
+// Import helpers
+import showChooser from './helpers/showChooser';
+import parseCommaSeparated from './helpers/parseCommaSeparated';
+import findProfilesByNames from './helpers/findProfilesByNames';
+import validateBrowsers from './helpers/validateBrowsers';
+import extractArgValue from './helpers/extractArgValue';
+import getRootPath from './helpers/getRootPath';
+
+// Import constants
+import AVAILABLE_BROWSERS from './constants/AVAILABLE_BROWSERS';
+
+// Get the project directory
+const pwd = getRootPath();
+
+// Find available profiles under /cypress/profiles
+const profilesDir = path.join(pwd, 'cypress/profiles');
+if (!fs.existsSync(profilesDir)) {
+  console.warn(`[cypress.config] Could not load profile '${profilesDir}'`);
+  process.exit(1);
+}
+
+// Find all files matching the pattern: {ProfileName}.Profile.ts
+const profileFiles = (
+  fs
+    .readdirSync(profilesDir)
+    .filter((f) => {
+      return f.endsWith('.Profile.ts');
+    })
+);
+
+// Get profile names by removing '.Profile.ts'
+const profiles = profileFiles.map((file) => {
+  const profileName = file.replace('.Profile.ts', '');
+  return { file, profileName };
+});
+
+// Exit if no profiles found
+if (profiles.length === 0) {
+  console.error(`No profiles found in '${profilesDir}'`);
+  process.exit(1);
+}
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+
+// Get selections from environment variables or CLI arguments
+let selectedProfiles: { file: string; profileName: string }[] = [];
+let selectedBrowsers: string[] = [];
+let isHeadless = false;
+
+// Check for PROFILE (env var or CLI arg)
+const envProfileRaw = process.env.PROFILE;
+const argProfileRaw = extractArgValue(args, '--profile');
+const profileRaw = envProfileRaw || argProfileRaw;
+
+if (profileRaw) {
+  const profileNames = parseCommaSeparated(profileRaw);
+  selectedProfiles = findProfilesByNames(profileNames, profiles);
+}
+
+// Check for BROWSER (env var or CLI arg)
+const envBrowserRaw = process.env.BROWSER;
+const argBrowserRaw = extractArgValue(args, '--browser');
+const browserRaw = envBrowserRaw || argBrowserRaw;
+
+if (browserRaw) {
+  const browserNames = parseCommaSeparated(browserRaw);
+  selectedBrowsers = validateBrowsers(browserNames);
+}
+
+// Check for HEADLESS (env var or CLI flag)
+const envHeadlessRaw = process.env.HEADLESS;
+const headlessFlagValue = extractArgValue(args, '--headless');
+const hasHeadlessFlag = headlessFlagValue !== undefined;
+isHeadless = !!(envHeadlessRaw && envHeadlessRaw.toLowerCase() !== 'false') || hasHeadlessFlag;
+
+// If headless wasn't specified, ask the user to choose
+if (!envHeadlessRaw && !hasHeadlessFlag) {
+  const choices = showChooser({
+    question: 'Run in headless mode?',
+    options: [
+      { tag: '1', description: 'Yes (headless)' },
+      { tag: '2', description: 'No (interactive)' },
+    ],
+    title: 'Select mode',
+    allowMulti: false,
+  });
+
+  isHeadless = choices[0].tag === '1';
+}
+
+// If running headless and no browsers were selected, ask the user to choose
+if (isHeadless && selectedBrowsers.length === 0) {
+  const options = AVAILABLE_BROWSERS.map(({ tag, name }) => {
+    return {
+      tag,
+      description: name,
+    };
+  });
+
+  const choices = showChooser({
+    question: 'Choose browser(s) (commas for multiple: C,F)',
+    options,
+    title: 'Select browser(s)',
+    allowMulti: true,
+  });
+
+  selectedBrowsers = (
+    choices
+      .map((choice) => {
+        return AVAILABLE_BROWSERS[choice.index];
+      })
+      .map(({ name }) => {
+        return name;
+      })
+  );
+}
+
+// If no profiles were selected, ask the user to choose
+// - In headless mode, allow selecting multiple profiles
+// - In visible mode, only allow selecting a single profile
+// In the case where their environment selected more than one profile, but they are not headless, make them re-choose
+if (
+  selectedProfiles.length === 0
+  || (!isHeadless && selectedProfiles.length > 1)
+) {
+  const options = profiles.map((p, idx) => {
+    return {
+      tag: String(idx + 1),
+      description: p.profileName,
+    };
+  });
+
+  const choices = showChooser({
+    question: (
+      isHeadless
+        ? 'Choose profile(s) (commas for multiple: 1,2):'
+        : 'Choose profile:'
+    ),
+    options,
+    title: `Choose profile${isHeadless ? 's' : ''}`,
+    allowMulti: isHeadless,
+  });
+
+  selectedProfiles = choices.map((choice) => { return profiles[choice.index]; });
+}
+
+// Execute commands for each combination of profile and browser (not yet implemented)
+console.log('Starting Cypress with the following configuration:');
+console.log(`Profiles: ${selectedProfiles.map((p) => { return p.profileName; }).join(', ')}`);
+console.log(`Browsers: ${selectedBrowsers.join(', ')}`);
+console.log(`Headless: ${isHeadless}`);

package/start/types/ChooserOption.ts

@@ -0,0 +1,11 @@
+/**
+ * An option that can be put into a chooser
+ * @author Gabe Abrams
+ */
+type ChooserOption = {
+  description: string,
+  tag?: string,
+  index?: number,
+};
+
+export default ChooserOption;

package/tsconfig.json

@@ -8,12 +8,11 @@
     "declaration": true,
     "sourceMap": true,
     "target": "es5",
+    "lib": ["es5", "es2015.promise", "es2017.object", "dom"],
     "outDir": "./lib"
   },
-  "include": [
-    "./src"
-  ],
+  "include": [ "./src", "setup", "start" ],
   "ts-node": {
     "files": true
   }
-}
+}

package/.eslintrc.json

@@ -1,58 +0,0 @@
-{
-  "extends": "airbnb",
-  "env": {
-    "browser": true,
-    "node": true
-  },
-  "rules": {
-    "arrow-body-style": [
-      "warn",
-      "always"
-    ],
-    "arrow-parens": [ "warn", "always" ],
-    "comma-dangle": [ "error", {
-      "arrays": "always-multiline",
-      "objects": "always-multiline",
-      "imports": "always-multiline",
-      "exports": "always-multiline",
-      "functions": "never"
-      }
-    ],
-    "consistent-return": "off",
-    "id-length": "off",
-    "max-len": [ "error",
-      {
-        "code": 80,
-        "ignoreStrings": true,
-        "ignoreTemplateLiterals": true,
-        "ignoreUrls": true
-      }
-    ],
-    "newline-per-chained-call": [
-      "error",
-      {
-        "ignoreChainWithDepth": 2
-      }
-    ],
-    "no-plusplus": [ "warn", { "allowForLoopAfterthoughts": true }],
-    "prefer-template": "off",
-    "prefer-destructuring": [ "error",
-      {
-        "VariableDeclarator": {
-         "array": false,
-         "object": true
-        },
-        "AssignmentExpression": {
-          "array": false,
-          "object": true
-        }
-      },
-      {
-        "enforceForRenamedProperties": false
-      }
-    ],
-    "radix": "off",
-    "no-underscore-dangle": "off",
-    "max-params": [ "warn", { "max": 3 } ]
-  }
-}

package/lib/genConfiguration.d.ts

@@ -1,8 +0,0 @@
-/**
- * Generate Cypress configuration based on global credentials,
- * variables, resources, and profiles
- * @author Yuen Ler Chow
- * ...
- */
-declare const genConfiguration: () => {};
-export default genConfiguration;

package/lib/genConfiguration.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * Generate Cypress configuration based on global credentials,
- * variables, resources, and profiles
- * @author Yuen Ler Chow
- * ...
- */
-var genConfiguration = function () {
-    return {};
-};
-exports.default = genConfiguration;
-//# sourceMappingURL=genConfiguration.js.map

package/lib/genConfiguration.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"genConfiguration.js","sourceRoot":"","sources":["../src/genConfiguration.ts"],"names":[],"mappings":";;AAAA;;;;;GAKG;AACH,IAAM,gBAAgB,GAAG;IACvB,OAAO,EAAE,CAAC;AACZ,CAAC,CAAC;AAEF,kBAAe,gBAAgB,CAAC"}

package/lib/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;AAAA,gDAA0B;AASxB,eATK,cAAI,CASL;AARN,wEAAkD;AAOhD,2BAPK,0BAAgB,CAOL;AALlB,sDAAsD;AACtD,IAAA,cAAI,GAAE,CAAC"}

package/lib/init.d.ts

@@ -1,13 +0,0 @@
-declare global {
-    namespace Cypress {
-        interface Chainable {
-            /**
-             * Custom command to click an element by selector
-             * @example cy.clickSomething('.my-button')
-             */
-            clickSomething(selector: string): Chainable<Element>;
-        }
-    }
-}
-declare const init: () => void;
-export default init;

package/lib/init.js

@@ -1,10 +0,0 @@
-"use strict";
-/// <reference types="cypress" />
-Object.defineProperty(exports, "__esModule", { value: true });
-var init = function () {
-    Cypress.Commands.add('clickSomething', function (selector) {
-        cy.get(selector).click();
-    });
-};
-exports.default = init;
-//# sourceMappingURL=init.js.map

package/lib/init.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.js","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":";AAAA,iCAAiC;;AAejC,IAAM,IAAI,GAAG;IACX,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAgB,EAAE,UAAC,QAAgB;QACtD,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,CAAC;IAC3B,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,kBAAe,IAAI,CAAC"}