dce-reactkit 3.8.7 → 3.9.0-beta-loading-modal.1

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

@@ -1,83 +0,0 @@
-// Import the function to be tested
-// import findURLs from './findURL';
-
-// // Import constants
-// import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Valid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const validTests: { block: string, expected: { start: number, end: number }[] }[] = [
-//   {
-//     block: 'Visit http://example.com for more information.',
-//     expected: [{ start: 6, end: 23 }],
-//   },
-//   {
-//     block: 'Multiple URLs: http://one.com and http://two.com.',
-//     expected: [
-//       { start: 15, end: 29 },
-//       { start: 34, end: 48 },
-//     ],
-//   },
-//   {
-//     block: 'Localhost URLs: http://localhost and http://127.0.0.1.',
-//     expected: [
-//       { start: 16, end: 31 },
-//       { start: 36, end: 52 },
-//     ],
-//   },
-//   {
-//     block: 'Embedded URL: text https://embedded-url.com?query=1&value=2.',
-//     expected: [{ start: 13, end: 51 }],
-//   },
-//   {
-//     block: 'Secure site: https://secure-site.com/path?query=string#fragment',
-//     expected: [{ start: 13, end: 58 }],
-//   },
-// ];
-
-// test(
-//   'Returns correct start and end indices for valid URLs within a string.',
-//   async () => {
-//     validTests.forEach(({ block, expected }) => {
-//       expect(findURLs(block)).toStrictEqual(expected);
-//     });
-//   },
-// );
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Invalid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const invalidTests: { block: string, expected: { start: number, end: number }[] }[] = [
-//   {
-//     block: 'No URL.',
-//     expected: [],
-//   },
-//   {
-//     block: 'URL format is wrong: http:/example.com and htt://example.com.',
-//     expected: [],
-//   },
-//   {
-//     block: 'Any punctuation after the URL http://example.com, should not count.',
-//     expected: [{ start: 20, end: 37 }],
-//   },
-//   {
-//     block: 'Starting punctuation ,http://example.com should not count.',
-//     expected: [{ start: 22, end: 39 }],
-//   },
-//   {
-//     block: 'Spaces in the middle http://exa mple.com is invalid.',
-//     expected: [],
-//   },
-// ];
-
-// test(
-//   'Returns empty array for strings without valid URLs.',
-//   async () => {
-//     invalidTests.forEach(({ block, expected }) => {
-//       expect(findURLs(block)).toStrictEqual(expected);
-//     });
-//   },
-// );

package/src/helpers/validators/findURL.ts

@@ -1,43 +0,0 @@
-// /**
-//  * This function finds URLs within a given string and returns an array of 
-//  * their locations.
-//  * @author Leisha Bhandari
-//  * @param block: The block of text to search for URLs
-//  * @returns Arrays where each of them contain the start and end index of the URL
-//  */
-// function findURLs(block: string): { start: number, end: number }[] {
-//   // Expression representing the skeleton of a URL to help match and find the  
-//   // URLs within the block of text (Also takes care of Unicode characters)
-//   const urlSkeleton = /(https?:\/\/[^\s\u0000-\u001F.,]+[^\s\u0000-\u001F.,]?(?:\?[^\s\u0000-\u001F]+)?(?:#[^\s\u0000-\u001F]+)?)/g;
-//   const found: { start: number, end: number }[] = [];
-//   let match: RegExpExecArray | null;
-
-//   // While loop to find the URLs in the given block of texts using the URL 
-//   // skeleton
-//   while ((match === urlSkeleton.exec(block)) 
-//          && match !== null) {
-//     // To find the beginning index of the URL
-//     let start = match.index;
-//     // To find the last index of the URL
-//     let end = match.index + match[0].length;
-
-//     // If statements to check whether the URL is followed by some kind of 
-//     // punctuation mark
-//     if (block.charAt(end) === '.' || /[,;:!?"]/.test(block.charAt(end))) {
-//       end--;
-//     }
-
-//     // While statement to make sure that the URL does not start with a 
-//     // punctuation mark
-//     while (start > 0 && /[.,:;!?]/.test(block.charAt(start - 1))) {
-//       start--;
-//     }
-
-//     // The object with start and end index of the URL is found and pushed to 
-//     // the found array
-//     found.push({ start, end });
-//   }
-  
-//   // Returns the array of the found URLs location
-//   return found;
-// }

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

@@ -1,90 +0,0 @@
-
-// Import the function to be tested
-// import isValid from './validURL';
-
-// // Import constants
-// import { INVALID_STRING_ERRORS, INVALID_REGEX_ERROR } from './shared/constants/ERROR_MESSAGES';
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Valid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const validUrls: string[] = [
-//   'http://example.com',
-//   'https://example.com',
-//   'http://www.example.com',
-//   'https://www.example.com',
-//   'https://example.com/path',
-//   'http://example.com/path',
-//   'https://example.com?query=string',
-//   'http://example.com?query=string',
-//   'https://example.com#fragment',
-//   'http://example.com#fragment',
-//   'http://localhost',
-//   'https://localhost:3000',
-//   'http://localhost:3000',
-//   'http://127.0.0.1',
-//   'http://127.0.0.1:3000',
-//   'ftp://example.com/path',
-//   'ftp://example.com',
-//   'https://127.0.0.1:3000',
-//   'file:///C:/path/to/file'
-// ];
-
-// test(
-//   'Returns true for a given valid URL.',
-//   async () => {
-//     validUrls.forEach((url) => {
-//       expect(isValid(url)).toBe(true);
-//     });
-//   },
-// );
-
-// /*------------------------------------------------------------------------*/
-// /* ---------------------------- Invalid Tests --------------------------- */
-// /*------------------------------------------------------------------------*/
-
-// const invalidUrls: string[] = [
-//   '',
-//   ' ',
-//   'example',
-//   'http://',
-//   'http://.',
-//   'http://..',
-//   'http://##/',
-//   'http://../',
-//   'http://??/',
-//   'http://#',
-//   'http://##',
-//   '//',
-//   '//a',
-//   '///a',
-//   '///',
-//   'http:///a',
-//   'http://www.foo.bar./',
-//   'http://foo.bar/foo(bar)baz quux',
-//   'http://3628126748',
-//   'http://.www.foo.bar/',
-//   'http://.www.foo.bar./',
-//   'http://123.123.123',
-//   'http://1.1.1.1.1',
-//   'http://example.com:99999',
-//   'http://example.com:80:80',
-//   'http://example.com::80',
-//   'http://example.com:-80',
-//   'http://-example.com',
-//   'http://example.com-',
-//   'http://example.com_',
-//   'http://example..com',
-//   'http://example.com.',
-//   'http://.example.com'
-// ];
-
-// test(
-//   'Returns false for a given invalid URL.',
-//   async () => {
-//     invalidUrls.forEach((url) => {
-//       expect(isValid(url)).toBe(false);
-//     });
-//   },
-// );

package/src/helpers/validators/validURL.ts

@@ -1,18 +0,0 @@
-/**
- * This function checks if a given input string is a valid URL.
- * @author Leisha Bhandari
- * @param URL: The input string that needs checked as a URL or not.
- * @returns A true boolean value if the input string is a valid URL, and a false
- *          boolean value if the input string is a invalid URL
- */
-function isValid(url: string): boolean {
-  // Uses the input URL to create a URL object
-  try {
-    new URL(url);
-    // URL constructor does not throw an error, so input URL is valid
-    return true;
-  } catch (err) {
-    // URL constructor throws an error, so input URL is invalid
-    return false;
-  }
-}

package/src/helpers/visitEndpointOnAnotherServer/index.ts

@@ -1,90 +0,0 @@
-// Import custom error
-import ErrorWithCode from '../../errors/ErrorWithCode';
-
-// Import shared types
-import ReactKitErrorCode from '../../types/ReactKitErrorCode';
-
-// Import other helpers
-import sendServerToServerRequest from './sendServerToServerRequest';
-
-/**
- * Send a server-to-server request from this sever to another server that uses
- *   dce-reactkit [for server only]
- * @author Gabe Abrams
- * @param opts object containing all arguments
- * @param opts.path - the path of the other server's endpoint
- * @param [opts.method=GET] - the method of the endpoint
- * @param [opts.params] - query/body parameters to include
- * @param [opts.headers] - headers to include
- * @returns response from server
- */
-const visitEndpointOnAnotherServer = async (
-  opts: {
-    path: string,
-    method?: ('GET' | 'POST' | 'DELETE' | 'PUT'),
-    params?: { [key in string]: any },
-    headers?: { [k in string]: any },
-  },
-): Promise<any> => {
-  // Remove properties with undefined values
-  let params: { [key in string]: any } | undefined;
-  if (opts.params) {
-    params = Object.fromEntries(
-      Object
-        .entries(opts.params)
-        .filter(([, value]) => {
-          return value !== undefined;
-        }),
-    );
-  }
-
-  // Automatically JSONify arrays and objects
-  if (params) {
-    params = Object.fromEntries(
-      Object
-        .entries(params)
-        .map(([key, value]) => {
-          if (Array.isArray(value) || typeof value === 'object') {
-            return [key, JSON.stringify(value)];
-          }
-          return [key, value];
-        }),
-    );
-  }
-
-  // Send the request
-  const response = await sendServerToServerRequest({
-    path: opts.path,
-    method: opts.method ?? 'GET',
-    params,
-  });
-
-  // Check for failure
-  if (!response || !response.body) {
-    throw new ErrorWithCode(
-      'We didn\'t get a response from the server. Please check your internet connection.',
-      ReactKitErrorCode.NoResponse,
-    );
-  }
-  if (!response.body.success) {
-    // Other errors
-    throw new ErrorWithCode(
-      (
-        response.body.message
-        || 'An unknown error occurred. Please contact an admin.'
-      ),
-      (
-        response.body.code
-        || ReactKitErrorCode.NoCode
-      ),
-    );
-  }
-
-  // Success! Extract the body
-  const { body } = response.body;
-
-  // Return
-  return body;
-};
-
-export default visitEndpointOnAnotherServer;

package/src/helpers/visitEndpointOnAnotherServer/sendServerToServerRequest.ts

@@ -1,164 +0,0 @@
-// Import libs
-import qs from 'qs';
-
-// Import shared types
-import ReactKitErrorCode from '../../types/ReactKitErrorCode';
-
-// Import custom error
-import ErrorWithCode from '../../errors/ErrorWithCode';
-
-/**
- * Sends and retries an http request
- * @author Gabriel Abrams
- * @param opts object containing all arguments
- * @param opts.path path to send request to
- * @param [opts.host] host to send request to
- * @param [opts.method=GET] http method to use
- * @param [opts.params] body/data to include in the request
- * @param [opts.headers] headers to include in the request
- * @param [opts.sendCrossDomainCredentials=true if in development mode] if true,
- *   send cross-domain credentials even if not in dev mode
- * @param [opts.responseType=JSON] expected response type
- * @returns { body, status, headers } on success
- */
-const sendServerToServerRequest = async (
-  opts: {
-    path: string,
-    host?: string,
-    method?: ('GET' | 'POST' | 'PUT' | 'DELETE'),
-    params?: { [k in string]: any },
-    headers?: { [k in string]: any },
-    responseType?: 'Text' | 'JSON',
-  },
-): Promise<{
-  body: any,
-  status: number,
-  headers: { [k in string]: any },
-}> => {
-  // Process method
-  const method: ('GET' | 'POST' | 'PUT' | 'DELETE') = (opts.method || 'GET');
-
-  // Encode objects within params
-  let params: {
-    [k in string]: any
-  } | undefined;
-  if (opts.params) {
-    params = {};
-    Object.entries(opts.params).forEach(([key, val]) => {
-      if (typeof val === 'object' && !Array.isArray(val)) {
-        (params as any)[key] = JSON.stringify(val);
-      } else {
-        (params as any)[key] = val;
-      }
-    });
-  }
-
-  // Stringify parameters
-  const stringifiedParams = qs.stringify(params || {}, {
-    encodeValuesOnly: true,
-    arrayFormat: 'brackets',
-  });
-
-  // Create url (include query if GET)
-  const query = (method === 'GET' ? `?${stringifiedParams}` : '');
-  let url;
-  if (!opts.host) {
-    // No host included at all. Just send to a path
-    url = `${opts.path}${query}`;
-  } else {
-    url = `https://${opts.host}${opts.path}${query}`;
-  }
-
-  // Update headers
-  const headers = opts.headers || {};
-  let data: string | null | { [k: string]: any } | undefined = null;
-  if (!headers['Content-Type']) {
-    // Form encoded
-    headers['Content-Type'] = 'application/x-www-form-urlencoded';
-    // Add data if applicable
-    data = (method !== 'GET' ? stringifiedParams : null);
-  } else {
-    // JSON encode
-    data = params;
-  }
-
-  // Encode data
-  let encodedData: URLSearchParams | string | undefined;
-  if (data) {
-    if (headers['Content-Type'] === 'application/x-www-form-urlencoded') {
-      encodedData = new URLSearchParams(params);
-    } else {
-      encodedData = JSON.stringify(data);
-    }
-  }
-
-  // Send request
-  try {
-    const response = await fetch(
-      url,
-      {
-        method,
-        mode: 'cors',
-        headers: headers ?? {},
-        body: (
-          (method !== 'GET' && encodedData)
-            ? encodedData
-            : undefined
-        ),
-        redirect: 'follow',
-      },
-    );
-
-    // Get headers map
-    const responseHeaders: {
-      [k in string]: string
-    } = {};
-    response.headers.forEach((value, key) => {
-      responseHeaders[key] = value;
-    });
-
-    // Process response based on responseType
-    try {
-      // Parse response
-      let responseBody: any;
-      if (
-        opts.responseType
-        && opts.responseType === 'Text'
-      ) {
-        // Response type is text
-        responseBody = await response.text();
-      } else {
-        // Response type is JSON
-        responseBody = await response.json();
-      }
-
-      // Return response
-      return {
-        body: responseBody,
-        status: response.status,
-        headers: responseHeaders,
-      };
-    } catch (err) {
-      throw new ErrorWithCode(
-        `Failed to parse response as ${opts.responseType}: ${(err as any)?.message}`,
-        ReactKitErrorCode.ResponseParseError,
-      );
-    }
-  } catch (err) {
-    // Self-signed certificate error:
-    if ((err as any)?.message?.includes('self signed certificate')) {
-      throw new ErrorWithCode(
-        'We refused to send a request because the receiver has self-signed certificates.',
-        ReactKitErrorCode.SelfSigned,
-      );
-    }
-
-    // No tries left
-    throw new ErrorWithCode(
-      `We encountered an error when trying to send a network request. If this issue persists, contact an admin. Error: ${(err as any)?.message}`,
-      ReactKitErrorCode.NotConnected,
-    );
-  }
-};
-
-export default sendServerToServerRequest;

package/src/types/DropdownItemType.ts

@@ -1,11 +0,0 @@
-// Types of dropdown items
-enum DropdownItemType {
-  // Dropdown header
-  Header = 'Header',
-  // Dropdown divider
-  Divider = 'Divider',
-  // Dropdown item
-  Item = 'Item',
-}
-
-export default DropdownItemType;