dce-reactkit 1.0.20 → 2.0.2

package/src-old/components/Alert.js

@@ -1,79 +0,0 @@
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-
-// Import bootstrap components
-import { Alert as BootstrapAlert } from 'reactstrap';
-// Import bootstrap stylesheet
-import 'bootstrap/dist/css/bootstrap.min.css';
-
-class Alert extends Component {
-  constructor(props) {
-    super(props);
-
-    this.state = {
-      visible: true,
-    };
-    this.closeClicked = this.closeClicked.bind(this);
-  }
-
-  closeClicked() {
-    this.setState({
-      visible: false,
-    });
-
-    // Call parent's onDismiss function
-    const { onDismiss } = this.props;
-    if (onDismiss) {
-      onDismiss();
-    }
-  }
-
-  render() {
-    // Extract properties
-    const {
-      dismissible,
-      onDismiss,
-      centered,
-      children,
-      ...props
-    } = this.props;
-
-    // Deconstruct state
-    const { visible } = this.state;
-
-    return (
-      <BootstrapAlert
-        isOpen={visible}
-        toggle={dismissible ? this.closeClicked : undefined}
-        style={{
-          textAlign: (centered ? 'center' : 'left'),
-        }}
-        {...props}
-      >
-        {children}
-      </BootstrapAlert>
-    );
-  }
-}
-
-Alert.propTypes = {
-  /* If true, the alert is dismissible */
-  dismissible: PropTypes.bool,
-  /* Handler to call when the alert is dismissed (only valid if dismissible) */
-  onDismiss: PropTypes.func,
-  /* If true, text is centered in the alert */
-  centered: PropTypes.bool,
-  /* Children (body) of the alert */
-  children: PropTypes.oneOfType([
-    PropTypes.arrayOf(PropTypes.node),
-    PropTypes.node,
-  ]).isRequired,
-};
-
-Alert.defaultProps = {
-  dismissible: false,
-  onDismiss: null,
-  centered: false,
-};
-
-export default Alert;

package/src-old/components/Button.js

@@ -1,64 +0,0 @@
-import React, { Component } from 'react';
-import PropTypes from 'prop-types';
-
-// Import bootstrap components
-import { Button as BootstrapButton } from 'reactstrap';
-// Import bootstrap stylesheet
-import 'bootstrap/dist/css/bootstrap.min.css';
-
-/* Allowed colors:
- * - primary
- * - secondary
- * - success
- * - info
- * - warning
- * - danger
- * - link
- *
- * To disable, include "disabled" tag
- * To use outline-style of button, include "outline" tag
- * To use block-style of button, include "block" tag
- *
- * Sizes:
- * - lg
- * - sm
- * - normal (used by default)
- */
-
-class Button extends Component {
-  render() {
-    // Extract properties
-    const {
-      text,
-      children,
-      ...props
-    } = this.props;
-
-    // Set up button style
-    return (
-      <BootstrapButton {...props}>
-        {text || children || 'Choose'}
-      </BootstrapButton>
-    );
-  }
-}
-
-Button.propTypes = {
-  /* Label text of the button */
-  text: PropTypes.string,
-  /* Body of the button (only valid if text is not included) */
-  children: PropTypes.oneOfType([
-    PropTypes.arrayOf(PropTypes.node),
-    PropTypes.node,
-  ]),
-  /* Also, all Bootstrap button props may be included:
-   * https://reactstrap.github.io/components/buttons/
-   */
-};
-
-Button.defaultProps = {
-  text: null,
-  children: null,
-};
-
-export default Button;

package/src-old/components/CSV/autoMatch.js

@@ -1,174 +0,0 @@
-import validators from '../../common/validators';
-import getNumCols from './getNumCols';
-
-/**
- * Performs auto csv header matching and determines the allowed manual matchings
- *   that a user can do (via dropowns)
- * @param {object} csv - the csv object to analyze
- * @param {object} headersToMatch - a list of headers to match against the csv
- *   headers
- * @param {string} headersToMatch[].key - the property name to use for the
- *   parsed version of the csv (for each row object, the value in this column
- *   will be found in row[key]). Example: 'name'
- * @param {string} headersToMatch[].title - a human-readable title of the column
- *   that needs to be matched. Example: 'Student Name'
- * @param {string} headersToMatch[].description - a human-readable description
- *   of the column that needs to be matched. Example: 'the student's full name'
- * @param {boolean} headersToMatch[].required - if true, the header must be
- *   matched before continuing. Otherwise, the header is allowed to remain
- *   unmatched
- * @param {string|function} headersToMatch[].validator - a validator function
- *   that must return true on all cells in a column for the column to be deemed
- *   valid for matching. If validator is a string, it must be a listed validator
- *   in /common/validators
- * @param {boolean} [allowEmpty] - if true, empty cells are not validated (they
- *   are deemed valid)
- * @param {array.<String>} headersToMatch[].titleGuesses - additional guesses
- *   for what the csv might be titling this column. Example:
- *   ['Full Name', 'Given Name'].
- *   We will always use headersToMatch[].title as one of the titleGuesses
- */
-export default (csv, headersToMatch) => {
-  // > Determine which headers can be matched to each column (use validator)
-  const allowedHeaders = {};
-  // ^ column index => array of headers that we can match this column with
-  const headerToAllowedColumns = [];
-  // ^ headerKey => array of column indices that we can match the header with
-  const numCols = getNumCols(csv);
-  for (let cIndex = 0; cIndex < numCols; cIndex++) {
-    // The key to look up the column in csv.data[i]
-    const columnHeader = (
-      csv.headers
-        ? csv.headers[cIndex]
-        : cIndex
-    );
-
-    // Loop through all headers and determine if it's allowed to be matched
-    for (let hIndex = 0; hIndex < headersToMatch.length; hIndex++) {
-      const headerToMatch = headersToMatch[hIndex];
-
-      // Check for a validator
-      let validationFailed;
-      let { validator } = headerToMatch;
-      if (typeof validator === 'string') {
-        validator = validators[validator];
-      }
-      if (validator) {
-        // Check that all cells in the column are valid
-        for (let rIndex = 0; rIndex < csv.data.length; rIndex++) {
-          const row = csv.data[rIndex];
-          const cell = row[columnHeader];
-
-          // Check for fail due to emptiness
-          if (
-            !headerToMatch.allowEmpty
-            && (!cell || cell.trim().length === 0)
-          ) {
-            validationFailed = true;
-            break;
-          }
-
-          // Check for fail due to validator
-          if (!validator(cell)) {
-            validationFailed = true;
-            break;
-          }
-        }
-      }
-
-      // Add to list if validation succeeded
-      if (!validationFailed) {
-        if (!allowedHeaders[cIndex]) {
-          allowedHeaders[cIndex] = [];
-        }
-        allowedHeaders[cIndex].push(headerToMatch);
-
-        if (!headerToAllowedColumns[headerToMatch.key]) {
-          headerToAllowedColumns[headerToMatch.key] = [];
-        }
-        headerToAllowedColumns[headerToMatch.key].push(cIndex);
-      }
-    }
-  }
-  console.log(allowedHeaders);
-
-  // Check that each header can be matched to at least one column
-  for (let i = 0; i < headersToMatch.length; i++) {
-    const allowedColumns = headerToAllowedColumns[headersToMatch[i].key];
-    if (!allowedColumns && headersToMatch[i].required) {
-      this.state = {
-        impossible: true,
-      };
-      return;
-    }
-  }
-
-  // Try to automatically match up columns
-  const columnMapping = {}; // column index => headerKey
-  const headerIsMatched = {}; // headerKey => true if already matched
-  const columnIsMatched = {}; // cIndex => true if already matched
-  // > If a column can only be assigned to one column, automatically assign it
-  Object.keys(headerToAllowedColumns).forEach((headerKey) => {
-    const allowedColumns = headerToAllowedColumns[headerKey];
-    if (allowedColumns.length === 1) {
-      // Save header mapping
-      columnMapping[allowedColumns[0]] = headerKey;
-      headerIsMatched[headerKey] = true;
-      columnIsMatched[allowedColumns[0]] = true;
-    }
-  });
-
-  // Match remaining columns by title guesses (if possible)
-  if (csv.headers) {
-    // We have header names to attempt to match
-    const headerToColumnsThatMatchGuesses = {};
-    // ^ headerKey => list of columns with title guesses that match
-    headersToMatch.forEach((header) => {
-      // Skip header if already matched
-      if (headerIsMatched[header.key]) {
-        return;
-      }
-
-      // Compile all title guesses (and add on actual title as a guess)
-      const titleGuesses = [header.title].concat(header.titleGuesses || []);
-
-      // Check all allowed columns
-      headerToAllowedColumns[header.key].forEach((cIndex) => {
-        // Skip column if already matched
-        if (columnIsMatched[cIndex]) {
-          return;
-        }
-
-        // Keep track of guesses that match
-        titleGuesses.forEach((titleGuess) => {
-          const fixedTitleGuess = titleGuess.trim().toLowerCase();
-          const fixedHeaderTitle = csv.headers[cIndex].trim().toLowerCase();
-          if (fixedTitleGuess === fixedHeaderTitle) {
-            // Found a match
-            if (!headerToColumnsThatMatchGuesses[header.key]) {
-              headerToColumnsThatMatchGuesses[header.key] = [];
-            }
-            headerToColumnsThatMatchGuesses[header.key].push(cIndex);
-          }
-        });
-      });
-    });
-
-    // If title guesses provide one option for matching, use it!
-    Object.keys(headerToColumnsThatMatchGuesses).forEach((headerKey) => {
-      const columnsThatMatch = headerToColumnsThatMatchGuesses[headerKey];
-      if (columnsThatMatch.length === 1) {
-        // Found one match!
-        // Save header mapping
-        columnMapping[columnsThatMatch[0]] = headerKey;
-        headerIsMatched[headerKey] = true;
-        columnIsMatched[columnsThatMatch[0]] = true;
-      }
-    });
-  }
-
-  return {
-    allowedHeaders,
-    columnMapping,
-  };
-};

package/src-old/components/CSV/getNumCols.js

@@ -1,15 +0,0 @@
-export default (csv) => {
-  let numCols;
-  if (csv.headers) {
-    numCols = csv.headers.length;
-  } else {
-    // No headers (assume rows are arrays)
-    // Number of columns equals the length of the longest row
-    csv.data.forEach((row) => {
-      if (!numCols || row.length > numCols) {
-        numCols = row.length;
-      }
-    });
-  }
-  return numCols;
-};