dce-reactkit 4.3.4 → 5.0.0-beta-progress-size-3

package/src/helpers/validators/validateString.test.ts

@@ -1,173 +0,0 @@
-// Import helpers
-import genCommaList from '../genCommaList';
-
-// Import types
-import ValidationResult from './shared/types/ValidationResult';
-
-// Import constants
-import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
-
-// Import function
-import validateString from './validateString';
-
-/*------------------------------------------------------------------------*/
-/* ---------------------------- Valid Tests --------------------------- */
-/*------------------------------------------------------------------------*/
-
-const validStrings: string[] = [
-  'users',
-  'username',
-  'MyValidString',
-  'HereisAnotherValidString',
-  'WoahAnotherValidStringIsHere',
-];
-
-const validReqs: {
-  // whitespace is removed from input before checking and returning
-  ignoreWhitespace?: boolean,
-  // input length must be at least minLen
-  minLen?: number,
-  // input length must be at most maxLen
-  maxLen?: number,
-  // input must only contain letters
-  lettersOnly?: boolean,
-  // input must only contain numbers
-  numbersOnly?: boolean,
-  // input must match given regExp
-  regexTest?: RegExp,
-  // description of regExp test, used to customize error messages
-  regexDescription?: string,
-}[] = [
-  {
-  },
-  {
-    minLen: 5,
-  },
-  {
-    minLen: 5,
-    maxLen: 30,
-  },
-  {
-    minLen: 5,
-    maxLen: 30,
-    lettersOnly: true,
-  },
-  {
-    minLen: 5,
-    maxLen: 30,
-    lettersOnly: true,
-    numbersOnly: false,
-  },
-  {
-    minLen: 5,
-    maxLen: 30,
-    lettersOnly: true,
-    numbersOnly: false,
-    ignoreWhitespace: false,
-  },
-];
-
-test(
-  'Returns true for a given valid string.',
-  async () => {
-    validStrings.forEach((validString) => {
-      validReqs.forEach((validReq) => {
-        const validResponse: ValidationResult<string> = {
-          isValid: true,
-          cleanedValue: validString,
-        };
-
-        expect(validateString(validString, validReq)).toStrictEqual(validResponse);
-      });
-    });
-
-    const validString = 'A string with whitespace!';
-
-    const validResponse: ValidationResult<string> = {
-      isValid: true,
-      cleanedValue: 'Astringwithwhitespace!',
-    };
-
-    const validOpt = {
-      maxLen: 22,
-      ignoreWhitespace: true,
-    };
-
-    expect(validateString(validString, validOpt)).toStrictEqual(validResponse);
-  },
-);
-
-/*------------------------------------------------------------------------*/
-/* ---------------------------- Invalid Tests --------------------------- */
-/*------------------------------------------------------------------------*/
-
-const invalidStrings: {
-  input: string,
-  reqs: {
-    // whitespace is removed from input before checking and returning
-    ignoreWhitespace?: boolean,
-    // input length must be at least minLen
-    minLen?: number,
-    // input length must be at most maxLen
-    maxLen?: number,
-    // input must only contain letters
-    lettersOnly?: boolean,
-    // input must only contain numbers
-    numbersOnly?: boolean,
-    // input must match given regExp
-    regexTest?: RegExp,
-    // description of regExp test, used to customize error messages
-    regexDescription?: string,
-  },
-  error: string[]
-}[] = [
-  {
-    input: 'ûšër',
-    reqs: {
-      minLen: 5,
-      lettersOnly: true,
-    },
-    error: [INVALID_STRING_ERRORS.MIN_LEN(5)],
-  },
-  {
-    input: '123456789',
-    reqs: {
-      minLen: 10,
-      maxLen: 5,
-      lettersOnly: true,
-    },
-    error: [INVALID_STRING_ERRORS.MIN_LEN(10), INVALID_STRING_ERRORS.MAX_LEN(5), INVALID_STRING_ERRORS.LETTERS_ONLY],
-  },
-  {
-    input: 'String with non-letters!!',
-    reqs: {
-      lettersOnly: true,
-      numbersOnly: true,
-      ignoreWhitespace: true,
-    },
-    error: [INVALID_STRING_ERRORS.LETTERS_ONLY, INVALID_STRING_ERRORS.NUMBERS_ONLY],
-  },
-  {
-    input: '12345678',
-    reqs: {
-      lettersOnly: true,
-      regexTest: /^\s*(?:\+?(\d{1,3}))?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{4})(?: *x(\d+))?\s*$/,
-      regexDescription: 'should be a phone number',
-    },
-    error: [INVALID_STRING_ERRORS.LETTERS_ONLY, `${INVALID_REGEX_ERROR}: should be a phone number`],
-  },
-];
-
-test(
-  'Returns false for a given invalid string.',
-  async () => {
-    invalidStrings.forEach((triple) => {
-      const invalidResponse: ValidationResult<string> = {
-        isValid: false,
-        errorMessage: `${INVALID_STRING_ERRORS.MESSAGE_INTRO}${genCommaList(triple.error)}.`,
-      };
-
-      expect(validateString(triple.input, triple.reqs)).toStrictEqual(invalidResponse);
-    });
-  },
-);

package/src/helpers/validators/validateString.ts

@@ -1,171 +0,0 @@
-// Import helpers
-import validateRegex from './shared/helpers/validateRegex';
-import genCommaList from '../genCommaList';
-
-// Import constants
-import { INVALID_STRING_ERRORS } from './shared/constants/ERROR_MESSAGES';
-
-// Import types
-import ValidationResult from './shared/types/ValidationResult';
-
-/*------------------------------------------------------------------------*/
-/* ------------------------------ Constants ----------------------------- */
-/*------------------------------------------------------------------------*/
-
-// define minimum and maximum range for lowercase ASCII chars
-const LOWERCASE_MIN = 65;
-const LOWERCASE_MAX = 90;
-
-// define minimum and maximum range for uppercase ASCII chars
-const UPPERCASE_MIN = 97;
-const UPPERCASE_MAX = 122;
-
-// define minimum and maximum range for ASCII digits
-const DIGIT_MIN = 48;
-const DIGIT_MAX = 57;
-
-/*------------------------------------------------------------------------*/
-/* ---------------------------- Main Function --------------------------- */
-/*------------------------------------------------------------------------*/
-
-/**
- * Determines whether a given input string is considered valid based on
- *   the provided requirements.
- * @author Austen Money
- * @param input input string
- * @param opts options for validation
- * @returns whether input is considered valid according to reqs - if
- *   valid, returns a cleaned version of input; if invalid, returns
- *   a string containing error messages describing which requirements
- *   were not met.
- */
-const validateString = (
-  input: string,
-  opts: {
-    // whitespace is removed from input before checking and returning
-    ignoreWhitespace?: boolean,
-    // input length must be at least minLen
-    minLen?: number,
-    // input length must be at most maxLen
-    maxLen?: number,
-    // input must only contain letters
-    // (future TODO: add option for passing in an array of permitted chars)
-    lettersOnly?: boolean,
-    // input must only contain numbers
-    numbersOnly?: boolean,
-    // input must match given regExp
-    regexTest?: RegExp,
-    // description of regExp test, used to customize error messages
-    regexDescription?: string,
-  },
-): ValidationResult<string> => {
-  // stores all invalid input errors
-  const errorMessages: string[] = [];
-
-  // contains version of input that will be returned
-  let cleanedValue: string = input;
-
-  // remove whitespace if required
-  if (opts.ignoreWhitespace) {
-    cleanedValue = input.replace(/\s+/g, '');
-  }
-
-  // apply max char requirement
-  if (opts.minLen) {
-    if (cleanedValue.length < opts.minLen) {
-      errorMessages.push(INVALID_STRING_ERRORS.MIN_LEN(opts.minLen));
-    }
-  }
-
-  // apply max char requirement
-  if (opts.maxLen) {
-    if (cleanedValue.length > opts.maxLen) {
-      errorMessages.push(INVALID_STRING_ERRORS.MAX_LEN(opts.maxLen));
-    }
-  }
-
-  // apply alphabetical requirement
-  if (opts.lettersOnly) {
-    // remove diacritics
-    cleanedValue = cleanedValue.normalize('NFD').replace(/[\u0300-\u036f]/g, '');
-
-    const containsNonLetters = (
-      cleanedValue
-        // split into characters
-        .split('')
-        // convert into character codes
-        .map((curr) => {
-          return curr.charCodeAt(0);
-        })
-        // check for non-letters
-        .some((currCode) => {
-          return (
-            !(currCode >= LOWERCASE_MIN && currCode <= LOWERCASE_MAX)
-            && !(currCode >= UPPERCASE_MIN && currCode <= UPPERCASE_MAX)
-          );
-        })
-    );
-
-    if (containsNonLetters) {
-      errorMessages.push(INVALID_STRING_ERRORS.LETTERS_ONLY);
-    }
-  }
-
-  // apply numerical requirement
-  if (opts.numbersOnly) {
-    const containsNonNumbers = (
-      cleanedValue
-        // split into characters
-        .split('')
-        // convert into character codes
-        .map((curr) => {
-          return curr.charCodeAt(0);
-        })
-        // check for non-numbers
-        .some((currCode) => {
-          return (
-            !(currCode >= DIGIT_MIN && currCode <= DIGIT_MAX)
-          );
-        })
-    );
-
-    if (containsNonNumbers) {
-      errorMessages.push(INVALID_STRING_ERRORS.NUMBERS_ONLY);
-    }
-  }
-
-  // apply regex requirement
-  if (opts.regexTest) {
-    const regex = opts.regexTest;
-
-    // validate and create customized error message if description is provided
-    const result = validateRegex({
-      input: cleanedValue,
-      regex,
-      regexDescription: opts.regexDescription,
-    });
-
-    // if string did not pass regex validation, add error message
-    if (result.isValid === false) {
-      errorMessages.push(result.errorMessage);
-    }
-  }
-
-  // combine all error messages into one string to return
-  const errorMessage = `${INVALID_STRING_ERRORS.MESSAGE_INTRO}${genCommaList(errorMessages)}.`;
-
-  return (
-    // if no error messages, string is valid; if not, it is invalid
-    errorMessages.length === 0
-      ? {
-        isValid: true,
-        cleanedValue,
-      }
-      : {
-        isValid: false,
-        errorMessage,
-      }
-  );
-};
-
-export default validateString;

package/src/helpers/waitMs.tsx

@@ -1,12 +0,0 @@
-/**
- * Wait for a certain number of ms
- * @author Gabe Abrams
- * @param ms number of ms to wait
- */
-const waitMs = async (ms = 0) => {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-};
-
-export default waitMs;

package/src/types/DayOfWeek.ts

@@ -1,15 +0,0 @@
-/**
- * Days of the week
- * @author Gabe Abrams
- */
-enum DayOfWeek {
-  Monday = 'm',
-  Tuesday = 't',
-  Wednesday = 'w',
-  Thursday = 'r',
-  Friday = 'f',
-  Saturday = 's',
-  Sunday = 'u',
-}
-
-export default DayOfWeek;

package/src/types/Log/LogMainInfo.ts

@@ -1,69 +0,0 @@
-// Import shared types
-import LogLevel from '../LogLevel';
-
-/**
- * Main information in a log event
- * @author Gabe Abrams
- */
-type LogMainInfo = {
-  // Unique id of the log event
-  id: string,
-  // First name of the user
-  userFirstName: string,
-  // Last name of the user
-  userLastName: string,
-  // User email
-  userEmail: string,
-  // User Canvas Id
-  userId: number,
-  // If true, the user is a learner
-  isLearner: boolean,
-  // If true, the user is an admin
-  isAdmin: boolean,
-  // If true, the user is a ttm
-  isTTM: boolean,
-  // The id of the Canvas course that the user launched from
-  courseId: number,
-  // The name of the Canvas course
-  courseName: string,
-  // Browser info
-  browser: {
-    // Name of the browser
-    name: string,
-    // Version of the browser
-    version: string,
-  },
-  // Device info
-  device: {
-    // Name of the operating system
-    os: string,
-    // If true, device is a mobile device
-    isMobile: boolean,
-  },
-  // Calendar year that the event is from
-  year: number,
-  // Month that the event is from (1 = Jan, 12 = Dec)
-  month: number,
-  // Day of the month that the event is from
-  day: number,
-  // Hour of the day (24hr) when the event occurred
-  hour: number,
-  // Minute of the day when the event occurred
-  minute: number,
-  // Timestamp of event (ms since epoch)
-  timestamp: number,
-  // Context of the event (each app determines how to organize contexts)
-  context: string,
-  // Subcontext of the event (each app determines how to organize subcontexts)
-  subcontext: string,
-  // List of tags that apply to this action (each app determines tag usage)
-  tags: string[],
-  // Log level
-  level: LogLevel,
-  // Additional optional custom metadata
-  metadata?: {
-    [k: string]: any,
-  },
-};
-
-export default LogMainInfo;

package/src/types/Log/LogSourceSpecificInfo.ts

@@ -1,25 +0,0 @@
-// Import shared types
-import LogSource from '../LogSource';
-
-/**
- * Log info that is specific to the type of source
- * @author Gabe Abrams
- */
-type LogSourceSpecificInfo = (
-  // Client
-  | {
-    // Source of the event
-    source: LogSource.Client,
-  }
-  // Server
-  | {
-    // Source of the event
-    source: LogSource.Server,
-    // Route path (e.g. /api/admin/courses/53450/blocks)
-    routePath: string,
-    // Route template (e.g. /api/admin/courses/:courseId/blocks)
-    routeTemplate: string,
-  }
-);
-
-export default LogSourceSpecificInfo;

package/src/types/Log/LogTypeSpecificInfo.ts

@@ -1,33 +0,0 @@
-// Import shared types
-import LogAction from '../LogAction';
-import LogType from '../LogType';
-
-/**
- * Log info that is specific to the type of log
- * @author Gabe Abrams
- */
-type LogTypeSpecificInfo = (
-  // Error
-  | {
-    // Type of the event
-    type: LogType.Error,
-    // The error message
-    errorMessage: string,
-    // The error code
-    errorCode: string,
-    // Error stack trace
-    errorStack: string,
-  }
-  // Action
-  | {
-    // Type of the event
-    type: LogType.Action,
-    // Target of the action (each app determines the list of targets)
-    // These are usually buttons, panels, elements, etc.
-    target: string,
-    // The type of action performed on the target
-    action: LogAction,
-  }
-);
-
-export default LogTypeSpecificInfo;

package/src/types/Log/index.ts

@@ -1,17 +0,0 @@
-// Import shared types
-import LogMainInfo from './LogMainInfo';
-import LogSourceSpecificInfo from './LogSourceSpecificInfo';
-import LogTypeSpecificInfo from './LogTypeSpecificInfo';
-
-/**
- * A single log event corresponding to an action performed by a user or an
- *   error encountered by a user
- * @author Gabe Abrams
- */
-type Log = (
-  LogMainInfo
-  & LogSourceSpecificInfo
-  & LogTypeSpecificInfo
-);
-
-export default Log;

package/src/types/LogAction.ts

@@ -1,52 +0,0 @@
-/**
- * Types of actions
- * @author Gabe Abrams
- */
-enum LogAction {
-  // Target was opened by the user (it was not on screen, but now it is)
-  Open = 'Open',
-  // Target was closed by the user (it was on screen, but now it is not)
-  Close = 'Close',
-  // Target was cancelled by the user (it was on closed without saving)
-  Cancel = 'Cancel',
-  // Target was expanded by the user (it always remains on screen, but size was changed)
-  Expand = 'Expand',
-  // Target was collapsed by the user (it always remains on screen, but size was changed)
-  Collapse = 'Collapse',
-  // Target was viewed by the user (only for items that are not opened or closed, those must use Open/Close actions)
-  View = 'View',
-  // Target interrupted the user (popup, dialog, validation message, etc. appeared without user prompting)
-  Interrupt = 'Interrupt',
-  // Target was created by the user (it did not exist before)
-  Create = 'Create',
-  // Target was modified by the user (it existed and was changed)
-  Modify = 'Modify',
-  // Target was deleted by the user (it existed and now it doesn't)
-  Delete = 'Delete',
-  // Target was added by the user (it already existed and was added to another place)
-  Add = 'Add',
-  // Target was removed by the user (it was removed from something but still exists)
-  Remove = 'Remove',
-  // Target was activated by the user (click, check, tap, keypress, etc.)
-  Activate = 'Activate',
-  // Target was deactivated by the user (click away, uncheck, tap outside of, tab away, etc.)
-  Deactivate = 'Deactivate',
-  // User showed interest in a target (hover, peek, etc.)
-  Peek = 'Peek',
-  // Halt a process (pause, etc.)
-  Halt = 'Halt',
-  // Resume a process (resume a halted process)
-  Resume = 'Resume',
-  // Jump to/seek to/reveal/go to/navigate to a target
-  Jump = 'Jump',
-  // Post a submission/message/etc. into the target
-  Post = 'Post',
-  // Like something
-  Like = 'Like',
-  // Dislike something
-  Dislike = 'Dislike',
-  // Unknown action
-  Unknown = 'Unknown',
-}
-
-export default LogAction;

package/src/types/LogBuiltInMetadata.ts

@@ -1,19 +0,0 @@
-/**
- * Built-in metadata for logs
- * @author Gabe Abrams
- */
-const LogBuiltInMetadata = {
-  // Contexts
-  Context: {
-    Uncategorized: 'Uncategorized',
-    ServerRenderedErrorPage: 'ServerRenderedErrorPage',
-    ServerEndpointError: 'ServerEndpointError',
-    ClientFatalError: 'ClientFatalError',
-  },
-  // Targets
-  Target: {
-    NoTarget: 'NoTarget',
-  },
-};
-
-export default LogBuiltInMetadata;

package/src/types/LogFunction.ts

@@ -1,46 +0,0 @@
-// Import shared types
-import Log from './Log';
-import LogAction from './LogAction';
-import LogLevel from './LogLevel';
-
-/**
- * Type of a log action function
- * @author Gabe Abrams
- */
-type LogFunction = (
-  opts: (
-    // Shared info
-    {
-      // Context of the event (each app determines how to organize contexts)
-      context: string | { _: string },
-      // Subcontext of the event (each app determines how to organize subcontexts)
-      subcontext?: string,
-      // List of tags that apply to this action (each app determines tag usage)
-      tags?: string[],
-      // Additional optional custom metadata
-      metadata?: {
-        [k: string]: any,
-      },
-      // Log level (default is info)
-      level?: LogLevel,
-    } & (
-      // Error
-      | {
-        // The error object to log
-        error: any,
-      }
-      // Action
-      | {
-        // The type of action performed
-        action: LogAction,
-        // Target of the action (each app determines the list of targets)
-        // These are usually buttons, panels, elements, etc.
-        // If no target is included, this should indicate that this is an action
-        // being performed on the whole feature (open/close/etc)
-        target?: string,
-      }
-    )
-  ),
-) => Promise<Log>;
-
-export default LogFunction;

package/src/types/LogLevel.ts

@@ -1,11 +0,0 @@
-/**
- * Allowed log levels
- * @author Gabe Abrams
- */
-enum LogLevel {
-  Warn = 'Warn',
-  Info = 'Info', // Default
-  Debug = 'Debug',
-}
-
-export default LogLevel;

package/src/types/LogMetadataContextMap.ts

@@ -1,15 +0,0 @@
-/**
- * Type of the context map in a LogMetadata file
- * @author Gabe Abrams
- */
-type LogMetadataContextMap = {
-  [k: string]: (
-    | string
-    | {
-      _: string,
-      [k: string]: string
-    }
-  )
-};
-
-export default LogMetadataContextMap;

package/src/types/LogMetadataTagMap.ts

@@ -1,9 +0,0 @@
-/**
- * Type of the tag map inside a LogMetadata file
- * @author Gabe Abrams
- */
-type LogMetadataTagMap = {
-  [k: string]: string
-};
-
-export default LogMetadataTagMap;

package/src/types/LogMetadataTargetMap.ts

@@ -1,9 +0,0 @@
-/**
- * Type of the target map inside a LogMetadata file
- * @author Gabe Abrams
- */
-type LogMetadataTargetMap = {
-  [k: string]: string
-};
-
-export default LogMetadataTargetMap;