dceky 1.0.0-beta-yuenler.1 → 1.0.0-beta-auto-import.1

package/src/commands/navigateToHref.ts

@@ -9,13 +9,11 @@ declare global {
     interface Chainable {
       /**
        * Navigate to href attribute of Harvard identity provider button
-       * @param opts object containing all arguments
-       * @param opts.item the CSS selector of interest
-       * @param opts.domain the domain of the page
-       * @returns The full URL constructed from the href
-       * @example cy.navigateToHref({ item: '#login-button', domain: 'https://example.com' })
+       * @author Yuen Ler Chow
+       * @param item the CSS selector of interest
+       * @return Cypress chainable containing the full URL string (hostname + href attribute value)
        */
-      navigateToHref(opts: { item: string; domain: string }): Chainable<string>;
+      navigateToHref(item: string): Chainable<string>;
     }
   }
 }
@@ -25,17 +23,30 @@ declare global {
 /*----------------------------------------*/
 
 const navigateToHref = () => {
-  Cypress.Commands.add('navigateToHref', (opts: { item: string; domain: string }) => {
-    const { item, domain } = opts;
-
-    cy.waitForElementVisible(item);
-    return cy
-      .get(item)
-      .invoke('attr', 'href')
-      .then((href: any) => {
-        return domain + href; 
-      }); 
-  });
+  Cypress.Commands.add(
+    'navigateToHref',
+    (
+      item: string,
+    ) => {
+      cy.waitForElementVisible(item);
+
+      // get hostname from current URL
+      const hostname = cy.url().then((url: string) => {
+        return new URL(url).hostname;
+      });
+
+      return cy
+        .get(item)
+        .invoke('attr', 'href')
+        .then((href: string) => {
+          // If the href is a relative URL, prepend the hostname
+          if (href.startsWith('/')) {
+            return hostname + href;
+          }
+          return href;
+        });
+    },
+  );
 };
 
 /*----------------------------------------*/

package/src/commands/runScript.ts

@@ -9,13 +9,13 @@ declare global {
     interface Chainable {
       /**
        * Run a script on the page
+       * @author Yuen Ler Chow
        * @param scriptLines the script to run in an anonymous function on the page.
        *   If multiple script arguments are included, each argument will be considered a
        *   new line of the script.
-       * @returns return value of the script
-       * @example cy.runScript('console.log("Hello");', 'return document.title;')
+       * @return Cypress chainable containing the return value from executing the script
        */
-      runScript(...scriptLines: string[]): Chainable<any>;
+      runScript(scriptLines: string): Chainable<any>;
     }
   }
 }
@@ -25,14 +25,19 @@ declare global {
 /*----------------------------------------*/
 
 const runScript = () => {
-  Cypress.Commands.add('runScript', (...scriptLines: string[]) => {
-    cy.log('Running script');
-    const fullScript = scriptLines.join('\n');
-    return cy.window().then((win: any) => {
-      const result = win.eval(fullScript);
-      return cy.wrap(result);
-    });
-  });
+  Cypress.Commands.add(
+    'runScript',
+    (
+      scriptLines: string,
+    ) => {
+      cy.log('Running script');
+      const fullScript = scriptLines;
+      return cy.window().then((win) => {
+        const result = win.eval(fullScript);
+        return cy.wrap(result);
+      });
+    },
+  );
 };
 
 /*----------------------------------------*/

package/src/commands/typeInto.ts

@@ -9,17 +9,22 @@ declare global {
     interface Chainable {
       /**
        * Type text into an element. This function first removes the previous text in the element
+       * @author Yuen Ler Chow
        * @param opts object containing all arguments
        * @param opts.item the CSS selector of interest
        * @param opts.text the text to type
-       * @param opts.pressEnter if true, after typing into the text field, simulate pressing enter
-       * @example cy.typeInto({ item: '#username', text: 'john_doe', pressEnter: false })
+       * @param [opts.pressEnter] if true, after typing into the text field, simulate pressing enter
+       * @param [opts.append] if true, append the text to the end of the existing text in the element instead of replacing it
+       * @return Cypress chainable containing the input element that text was typed into
        */
-      typeInto(opts: {
-        item: string;
-        text: string;
-        pressEnter?: boolean;
-      }): Chainable<Element>;
+      typeInto(
+        opts: {
+          item: string,
+          text: string,
+          pressEnter?: boolean,
+          append?: boolean,
+        },
+      ): Chainable<Element>;
     }
   }
 }
@@ -29,25 +34,48 @@ declare global {
 /*----------------------------------------*/
 
 const typeInto = () => {
-  Cypress.Commands.add('typeInto', (opts: { item: string; text: string; pressEnter?: boolean }) => {
-    const { item, text, pressEnter } = opts;
-    cy.log(`Type "${text}" into ${item}`);
-    
-    // Check if the text contains an enter key press
-    const enterAtEndOfText = text.charAt(text.length - 1) === '\n';
-    
-    // Type the text without a trailing enter if there was one
-    const textWithoutTrailingEnter = enterAtEndOfText 
-      ? text.substring(0, text.length - 1)
-      : text;
-    
-    cy.get(item).clear().type(textWithoutTrailingEnter);
-    
-    // Press enter if explicitly requested or if text ended with newline
-    if (pressEnter || enterAtEndOfText) {
-      cy.get(item).type('{enter}');
-    }
-  });
+  Cypress.Commands.add(
+    'typeInto',
+    (
+      opts: {
+        item: string,
+        text: string,
+        pressEnter?: boolean,
+        append?: boolean,
+      },
+    ) => {
+      const {
+        item, text, pressEnter, append,
+      } = opts;
+      cy.log(`Type "${text}" into ${item}`);
+
+      // Check if the text contains an enter key press
+      const enterAtEndOfText = text.charAt(text.length - 1) === '\n';
+
+      // Type the text without a trailing enter if there was one
+      const textWithoutTrailingEnter = (
+        enterAtEndOfText
+          ? text.substring(0, text.length - 1)
+          : text
+      );
+
+      if (append) {
+        cy
+          .get(item)
+          .type(textWithoutTrailingEnter);
+      } else {
+        cy
+          .get(item)
+          .clear()
+          .type(textWithoutTrailingEnter);
+      }
+
+      // Press enter if explicitly requested or if text ended with newline
+      if (pressEnter || enterAtEndOfText) {
+        cy.get(item).type('{enter}');
+      }
+    },
+  );
 };
 
 /*----------------------------------------*/

package/src/commands/visitCanvasGETEndpoint.ts

@@ -9,13 +9,18 @@ declare global {
     interface Chainable {
       /**
        * Makes a GET request to Canvas API endpoint
+       * @author Yuen Ler Chow
        * @param opts object containing all arguments
        * @param opts.path The API path (e.g., '/courses', '/users/self')
        * @param opts.accessToken The Canvas access token
-       * @returns The API response body
-       * @example cy.visitCanvasGETEndpoint({ path: '/courses', accessToken: 'your_token' })
+       * @return Cypress chainable containing the Canvas API response body
        */
-      visitCanvasGETEndpoint(opts: { path: string; accessToken: string }): Chainable<any>;
+      visitCanvasGETEndpoint(
+        opts: {
+          path: string,
+          accessToken: string,
+        }
+      ): Chainable<any>;
     }
   }
 }
@@ -25,20 +30,28 @@ declare global {
 /*----------------------------------------*/
 
 const visitCanvasGETEndpoint = () => {
-  Cypress.Commands.add('visitCanvasGETEndpoint', (opts: { path: string; accessToken: string }) => {
-    cy.log('Visiting Canvas GET endpoint');
-    const { path, accessToken } = opts;
+  Cypress.Commands.add(
+    'visitCanvasGETEndpoint',
+    (
+      opts: {
+        path: string,
+        accessToken: string,
+      },
+    ) => {
+      cy.log('Visiting Canvas GET endpoint');
+      const { path, accessToken } = opts;
 
-    cy.log('Canvas API: ' + path);
-    return cy.request({
-      method: 'GET',
-      url: 'https://canvas.harvard.edu/api/v1' + path,
-      qs: {
-        per_page: 200,
-        access_token: accessToken
-      }
-    }).its('body');
-  });
+      cy.log(`Canvas API: ${path}`);
+      return cy.request({
+        method: 'GET',
+        url: `https://canvas.harvard.edu/api/v1${path}`,
+        qs: {
+          per_page: 200,
+          access_token: accessToken,
+        },
+      }).its('body');
+    },
+  );
 };
 
 /*----------------------------------------*/

package/src/commands/waitForElementVisible.ts

@@ -9,11 +9,15 @@ declare global {
     interface Chainable {
       /**
        * Wait for an element to be visible
+       * @author Yuen Ler Chow
        * @param item the CSS selector of interest
-       * @param timeoutSec the number of seconds to wait before timing out (default: 10)
-       * @example cy.waitForElementVisible('#submit-button', 15)
+       * @param [timeoutSec=10] the number of seconds to wait before timing out
+       * @return Cypress chainable containing the visible element
        */
-      waitForElementVisible(item: string, timeoutSec?: number): Chainable<JQuery<HTMLElement>>;
+      waitForElementVisible(
+        item: string,
+        timeoutSec?: number,
+      ): Chainable<JQuery<HTMLElement>>;
     }
   }
 }
@@ -23,14 +27,19 @@ declare global {
 /*----------------------------------------*/
 
 const waitForElementVisible = () => {
-  Cypress.Commands.add('waitForElementVisible', (item: string, timeoutSec?: number) => {
-    cy.log('Waiting for element to be visible');
-    timeoutSec = timeoutSec || 10;
+  Cypress.Commands.add(
+    'waitForElementVisible',
+    (
+      item: string,
+      timeoutSec?: number,
+    ) => {
+      cy.log('Waiting for element to be visible');
 
-    const timeoutMs = timeoutSec * 1000;
-    cy.log(`Wait for ${item} to be visible`);
-    return cy.get(item, { timeout: timeoutMs }).should('be.visible');
-  });
+      const timeoutMs = (timeoutSec || 10) * 1000;
+      cy.log(`Wait for ${item} to be visible`);
+      return cy.get(item, { timeout: timeoutMs }).should('be.visible');
+    },
+  );
 };
 
 /*----------------------------------------*/

package/src/genCommandPaths.ts

@@ -0,0 +1,65 @@
+import * as fs from 'fs';
+import * as path from 'path';
+
+/**
+ * Generate a file containing paths to all command files in cypress/commands
+ * This should be called from cypress.config.js (Node.js context)
+ * @param projectRoot - The root directory of the Cypress project (optional, defaults to process.cwd())
+ * @returns The path to the generated file
+ * @author Gabe Abrams
+ */
+const genCommandPaths = (): string => {
+  const root = process.cwd();
+  const cypressCommandsDir = path.resolve(root, 'cypress', 'commands');
+  const outputFile = path.resolve(cypressCommandsDir, '.dceky-paths.js');
+
+  // Check if the directory exists
+  if (!fs.existsSync(cypressCommandsDir)) {
+    // eslint-disable-next-line no-console
+    console.warn(`Cypress commands directory not found at: ${cypressCommandsDir}`);
+    // Create an empty file so init doesn't fail
+    fs.writeFileSync(outputFile, 'module.exports = [];\n');
+    return outputFile;
+  }
+
+  // Get all files in the directory
+  const files = fs.readdirSync(cypressCommandsDir);
+  const commandPaths: string[] = [];
+
+  // Filter out non-JS/TS files and process each file
+  files.forEach((file) => {
+    // Skip non-JS files (like .d.ts, .map, etc.)
+    if (!file.endsWith('.js') && !file.endsWith('.ts')) {
+      return;
+    }
+
+    // Skip index files and the generated paths file
+    if (file === 'index.js' || file === 'index.ts' || file === '.dceky-paths.js') {
+      return;
+    }
+
+    const filePath = path.join(cypressCommandsDir, file);
+
+    // Check if it's a file (not a directory)
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile()) {
+      return;
+    }
+
+    // Store the relative path from cypress/commands
+    commandPaths.push(file);
+  });
+
+  const content = `// Auto-generated by dceky - do not edit manually
+module.exports = ${JSON.stringify(commandPaths, null, 2)};
+`;
+
+  fs.writeFileSync(outputFile, content);
+
+  // eslint-disable-next-line no-console
+  console.log(`Generated command paths file: ${outputFile} (${commandPaths.length} commands)`);
+
+  return outputFile;
+};
+
+export default genCommandPaths;

package/src/index.ts

@@ -1,12 +1,11 @@
 // Import helpers
 import init from './init';
 import genConfiguration from './genConfiguration';
-
-// Automatically initialize upon importing the library
-init();
+import genCommandPaths from './genCommandPaths';
 
 // Export key functions
 export {
   genConfiguration,
+  genCommandPaths,
   init,
 };

package/src/init.ts

@@ -1,37 +1,83 @@
-// Import all commands
-import assertDoesNotHaveClass from './commands/assertDoesNotHaveClass';
-import assertHasClass from './commands/assertHasClass';
-import assertNumElements from './commands/assertNumElements';
-import clickWithRetry from './commands/clickWithRetry';
-import getNumElements from './commands/getNumElements';
-import handleHarvardKey from './commands/handleHarvardKey';
-import launchAs from './commands/launchAs';
-import launchLTIUsingToken from './commands/launchLTIUsingToken';
-import navigateToHref from './commands/navigateToHref';
-import runScript from './commands/runScript';
-import typeInto from './commands/typeInto';
-import visitCanvasGETEndpoint from './commands/visitCanvasGETEndpoint';
-import waitForElementVisible from './commands/waitForElementVisible';
-
-/**
- * Initialize custom commands
- * @author Gabe Abrams
- */
-const init = () => {
-  // Execute each command adder
-  assertDoesNotHaveClass();
-  assertHasClass();
-  assertNumElements();
-  clickWithRetry();
-  getNumElements();
-  handleHarvardKey();
-  launchAs();
-  launchLTIUsingToken();
-  navigateToHref();
-  runScript();
-  typeInto();
-  visitCanvasGETEndpoint();
-  waitForElementVisible();
+import fs from 'fs';
+import path from 'path';
+// // Import all commands
+// import assertDoesNotHaveClass from './commands/assertDoesNotHaveClass';
+// import assertHasClass from './commands/assertHasClass';
+// import assertNumElements from './commands/assertNumElements';
+// import getNumElements from './commands/getNumElements';
+// import handleHarvardKey from './commands/handleHarvardKey';
+// import launchAs from './commands/launchAs';
+// import launchLTIUsingToken from './commands/launchLTIUsingToken';
+// import navigateToHref from './commands/navigateToHref';
+// import runScript from './commands/runScript';
+// import typeInto from './commands/typeInto';
+// import visitCanvasGETEndpoint from './commands/visitCanvasGETEndpoint';
+// import waitForElementVisible from './commands/waitForElementVisible';
+
+// /**
+//  * Initialize custom commands
+//  * @author Gabe Abrams
+//  */
+// const init = (CypressRequire: <T = any>(id: string) => T) => {
+//   // Execute each built-in command adder
+//   assertDoesNotHaveClass();
+//   assertHasClass();
+//   assertNumElements();
+//   getNumElements();
+//   handleHarvardKey();
+//   launchAs();
+//   launchLTIUsingToken();
+//   navigateToHref();
+//   runScript();
+//   typeInto();
+//   visitCanvasGETEndpoint();
+//   waitForElementVisible();
+
+//   /* --------------- Run Cypress.Require on consumer's commands --------------- */
+
+//   try {
+//     // const commandPaths: string[] = CypressRequire('cypress/commands/.dceky-paths.js');
+
+//     // cy.log('commandPaths', commandPaths);
+
+//     // commandPaths.forEach((file) => {
+//     //   try {
+//     //     CypressRequire(`cypress/commands/${file}`);
+//     //   } catch (error) {
+//     //     // eslint-disable-next-line no-console
+//     //     console.error(`Error loading command from ${file}:`, error);
+//     //   }
+//     // });
+//     CypressRequire('../commands/playVideo.ts').default();
+//   } catch (error) {
+//     // eslint-disable-next-line no-console
+//     console.warn(
+//       `Could not load consumer commands. Make sure to call genCommandPaths() in your cypress.config.js: ${error}`,
+//     );
+//   }
+// };
+
+// export default init;
+
+const init = (CypressRequire: <T = any>(id: string) => T, c: any) => {
+  c.log('dceky init called!');
+  try {
+    // const pwd = (process.env.PWD || process.env.CWD);
+    const pwd = __dirname;
+    c.log('pwd:', pwd);
+    const playVideoPath = path.join(pwd, '../../../../cypress/commands/playVideo.ts');
+    c.log('playVideoPath:', playVideoPath);
+    c.log('About to require playVideo...');
+    const playVideoModule = CypressRequire(playVideoPath);
+    c.log('playVideo module:', playVideoModule);
+    playVideoModule.default();
+    c.log('playVideo.default() called successfully');
+  } catch (error) {
+    c.log('Error in dceky init:', error.message);
+    c.log(
+      `Could not load consumer commands. Make sure to call genCommandPaths() in your cypress.config.js: ${error}`,
+    );
+  }
 };
 
 export default init;

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/src/commands/clickWithRetry.ts

@@ -1,51 +0,0 @@
-/// <reference types="cypress" />
-
-/*----------------------------------------*/
-/* ---------------- Type ---------------- */
-/*----------------------------------------*/
-
-declare global {
-  namespace Cypress {
-    interface Chainable {
-      /**
-       * Click an element with visibility checking, scrolling, and timeout handling
-       * @param item the CSS selector of interest
-       * @param timeoutSec the number of seconds to wait before timing out (default: 10)
-       * @param dontScrollTo if true, do not scroll to the element (default: false)
-       * @example cy.clickWithRetry('.submit-button', 15, false)
-       */
-      clickWithRetry(item: string, timeoutSec?: number, dontScrollTo?: boolean): Chainable<JQuery<HTMLElement>>;
-    }
-  }
-}
-
-/*----------------------------------------*/
-/* --------------- Command -------------- */
-/*----------------------------------------*/
-
-const clickWithRetry = () => {
-  Cypress.Commands.add('clickWithRetry', (item: string, timeoutSec?: number, dontScrollTo?: boolean) => {
-    timeoutSec = timeoutSec || 10;
-    dontScrollTo = dontScrollTo || false;
-
-    cy.log(`Click ${item}`);
-    
-    // Wait for element to be visible first using our own function
-    cy.waitForElementVisible(item, timeoutSec);
-    
-    // If scrolling is disabled, try to click directly
-    if (dontScrollTo) {
-      return cy.get(item).click();
-    } else {
-      // Scroll to element and then click using our own function
-      cy.get(item).scrollIntoView();
-      return cy.get(item).click();
-    }
-  });
-};
-
-/*----------------------------------------*/
-/* --------------- Export --------------- */
-/*----------------------------------------*/
-
-export default clickWithRetry;