@pie-element/complex-rubric 2.6.6 → 2.6.8

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/absolute/index.js

@@ -1,31 +0,0 @@
-import Absolute from './component';
-import debug from 'debug';
-import { equalPoints, sameAxes } from '../../utils';
-
-const log = debug('pie-lib:graphing:absolute');
-
-export const tool = () => ({
-  type: 'absolute',
-  Component: Absolute,
-  complete: (data, mark) => ({ ...mark, building: false, closed: true }),
-  addPoint: (point, mark) => {
-    log('add point to absolute model: ', point, 'mark: ', mark);
-    if (mark && (equalPoints(mark.root, point) || sameAxes(mark.root, point))) {
-      return mark;
-    }
-
-    if (!mark) {
-      return {
-        type: 'absolute',
-        root: point,
-        edge: undefined,
-        closed: false,
-        building: true,
-      };
-    } else if (mark && !mark.root) {
-      throw new Error('no root - should never happen');
-    } else {
-      return { ...mark, edge: point, closed: true, building: false };
-    }
-  },
-});

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/circle/bg-circle.jsx

@@ -1,88 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { withStyles } from '@material-ui/core/styles';
-import classNames from 'classnames';
-import { types, gridDraggable } from '../../../plot';
-import { color } from '../../../render-ui';
-import * as utils from '../../utils';
-import { disabled, correct, incorrect, missing } from '../shared/styles';
-
-/**
- * A low level circle component
- *
- * TODO: This and base point have a lot of similarities - merge commonality
- *
- */
-class RawCircle extends React.Component {
-  static propTypes = {
-    classes: PropTypes.object.isRequired,
-    className: PropTypes.string,
-    correctness: PropTypes.string,
-    disabled: PropTypes.bool,
-    x: PropTypes.number.isRequired,
-    y: PropTypes.number.isRequired,
-    radius: PropTypes.number,
-    graphProps: types.GraphPropsType.isRequired,
-  };
-
-  render() {
-    const { classes, disabled, className, correctness, x, y, radius, graphProps, ...rest } = this.props;
-    const { scale } = graphProps;
-    const rx = Math.abs(scale.x(x + radius) - scale.x(x));
-    const ry = Math.abs(scale.y(y + radius) - scale.y(y));
-
-    return (
-      <ellipse
-        className={classNames(classes.bgCircle, disabled && classes.disabled, classes[correctness], className)}
-        cx={scale.x(x)}
-        cy={scale.y(y)}
-        rx={rx}
-        ry={ry}
-        {...rest}
-      />
-    );
-  }
-}
-
-const applyStyle = (fn) => ({
-  ...fn('stroke'),
-  '&:hover': {
-    strokeWidth: 3,
-    ...fn('stroke'),
-  },
-});
-
-const styles = () => ({
-  bgCircle: {
-    fill: 'transparent',
-    stroke: color.defaults.PRIMARY_LIGHT,
-    strokeWidth: 3,
-    transition: 'stroke 200ms ease-in, stroke-width 200ms ease-in',
-    '&:hover': {
-      strokeWidth: 6,
-      stroke: color.defaults.PRIMARY_DARK,
-    },
-  },
-  disabled: applyStyle(disabled),
-  correct: applyStyle(correct),
-  incorrect: applyStyle(incorrect),
-  missing: applyStyle(missing),
-});
-
-export const BgCircle = withStyles(styles)(RawCircle);
-
-export default gridDraggable({
-  bounds: (props, { domain, range }) => {
-    const { x, y } = props;
-    const area = { left: x, top: y, bottom: y, right: x };
-    return utils.bounds(area, domain, range);
-  },
-  anchorPoint: (props) => {
-    const { x, y } = props;
-    return { x, y };
-  },
-  fromDelta: (props, delta) => {
-    const newPoint = utils.point(props).add(utils.point(delta));
-    return newPoint;
-  },
-})(BgCircle);

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/circle/component.jsx

@@ -1,292 +0,0 @@
-import React from 'react';
-import PropTypes from 'prop-types';
-import { withStyles } from '@material-ui/core/styles';
-import { BasePoint } from '../shared/point';
-import BgCircle from './bg-circle';
-import { getMiddleOfTwoPoints, point, equalPoints } from '../../utils';
-import classNames from 'classnames';
-import { types } from '../../../plot';
-import { rootEdgeComponent } from '../shared/line/with-root-edge';
-import ReactDOM from 'react-dom';
-import MarkLabel from '../../mark-label';
-import isEmpty from 'lodash/isEmpty';
-import { color } from '../../../render-ui';
-
-const opacityPulsate = (opacity) => ({
-  '0%': { opacity: '0.0' },
-  '50%': { opacity },
-  '100%': { opacity: '0.0' },
-});
-
-const getRadius = (from, outer) => {
-  const c = point(from);
-  return c.dist(point(outer));
-};
-
-export class RawBaseCircle extends React.Component {
-  static propTypes = {
-    building: PropTypes.bool,
-    classes: PropTypes.object.isRequired,
-    className: PropTypes.string,
-    coordinatesOnHover: PropTypes.bool,
-    correctness: PropTypes.string,
-    from: types.PointType,
-    disabled: PropTypes.bool,
-    to: types.PointType,
-    middle: types.PointType,
-    onChange: PropTypes.func.isRequired,
-    onDragStart: PropTypes.func,
-    onDragStop: PropTypes.func,
-    graphProps: types.GraphPropsType.isRequired,
-    onClick: PropTypes.func,
-    labelNode: PropTypes.object,
-    labelModeEnabled: PropTypes.bool,
-    changeMarkProps: PropTypes.func,
-  };
-
-  static defaultProps = {
-    onClick: () => ({}),
-  };
-
-  onChangePoint = (point) => {
-    const { middle, onChange } = this.props;
-    const { from, to } = point;
-
-    // because point.from.label and point.to.label can be different
-    if (!equalPoints(from, to)) {
-      if (middle) {
-        point.middle = { ...middle, ...getMiddleOfTwoPoints(from, to) };
-      }
-
-      onChange(point);
-    }
-  };
-
-  dragFrom = (draggedFrom) => {
-    const { from, to } = this.props;
-
-    if (from.label) {
-      draggedFrom.label = from.label;
-    }
-
-    if (!equalPoints(draggedFrom, to)) {
-      this.onChangePoint({ from: draggedFrom, to });
-    }
-  };
-
-  dragTo = (draggedTo) => {
-    const { from, to } = this.props;
-
-    if (to.label) {
-      draggedTo.label = to.label;
-    }
-
-    if (!equalPoints(from, draggedTo)) {
-      this.onChangePoint({ from, to: draggedTo });
-    }
-  };
-
-  dragCircle = (draggedFrom) => {
-    const { from, to, onChange, middle } = this.props;
-    const diff = point(from).sub(point(draggedFrom));
-    const draggedTo = point(to).sub(diff);
-
-    if (from.label) {
-      draggedFrom.label = from.label;
-    }
-
-    if (to.label) {
-      draggedTo.label = to.label;
-    }
-
-    const updated = { from: draggedFrom, to: draggedTo };
-
-    if (middle) {
-      updated.middle = { ...middle, ...getMiddleOfTwoPoints(draggedFrom, draggedTo) };
-    }
-
-    this.setState(
-      {
-        draggedroot: undefined,
-        draggedOuter: undefined,
-        isCircleDrag: false,
-      },
-      () => {
-        onChange(updated);
-      },
-    );
-  };
-
-  labelChange = (point, type) => {
-    const { changeMarkProps } = this.props;
-    const update = { ...point };
-
-    if (!point.label || isEmpty(point.label)) {
-      delete update.label;
-    }
-
-    changeMarkProps({ [type]: update });
-  };
-
-  clickPoint = (point, type, data) => {
-    const { changeMarkProps, disabled, from, to, labelModeEnabled, onClick } = this.props;
-
-    if (!labelModeEnabled) {
-      onClick(point || data);
-      return;
-    }
-
-    if (disabled) {
-      return;
-    }
-
-    if (type === 'middle' && !point && from && to) {
-      point = { ...point, ...getMiddleOfTwoPoints(from, to) };
-    }
-
-    changeMarkProps({ from, to, [type]: { label: '', ...point } });
-
-    if (this.input[type]) {
-      this.input[type].focus();
-    }
-  };
-
-  // IMPORTANT, do not remove
-  input = {};
-
-  render() {
-    let {
-      from,
-      to,
-      middle,
-      disabled,
-      classes,
-      coordinatesOnHover,
-      building,
-      onDragStart,
-      onDragStop,
-      onClick,
-      correctness,
-      graphProps,
-      labelNode,
-      labelModeEnabled,
-    } = this.props;
-    const common = { onDragStart, onDragStop, graphProps, onClick };
-
-    to = to || from;
-
-    const radius = getRadius(from, to);
-
-    let fromLabelNode = null;
-    let toLabelNode = null;
-    let circleLabelNode = null;
-
-    if (labelNode) {
-      if (from && from.hasOwnProperty('label')) {
-        fromLabelNode = ReactDOM.createPortal(
-          <MarkLabel
-            inputRef={(r) => (this.input.from = r)}
-            disabled={!labelModeEnabled}
-            mark={from}
-            graphProps={graphProps}
-            onChange={(label) => this.labelChange({ ...from, label }, 'from')}
-          />,
-          labelNode,
-        );
-      }
-
-      if (to && to.hasOwnProperty('label')) {
-        toLabelNode = ReactDOM.createPortal(
-          <MarkLabel
-            inputRef={(r) => (this.input.to = r)}
-            disabled={!labelModeEnabled}
-            mark={to}
-            graphProps={graphProps}
-            onChange={(label) => this.labelChange({ ...to, label }, 'to')}
-          />,
-          labelNode,
-        );
-      }
-
-      if (middle && middle.hasOwnProperty('label')) {
-        circleLabelNode = ReactDOM.createPortal(
-          <MarkLabel
-            inputRef={(r) => (this.input.middle = r)}
-            disabled={!labelModeEnabled}
-            mark={middle}
-            graphProps={graphProps}
-            onChange={(label) => this.labelChange({ ...middle, label }, 'middle')}
-          />,
-          labelNode,
-        );
-      }
-    }
-
-    return (
-      <g>
-        <BgCircle
-          disabled={building || disabled}
-          correctness={correctness}
-          className={classNames(building && classes.bgCircleBuilding)}
-          x={from.x}
-          y={from.y}
-          radius={radius}
-          onDrag={this.dragCircle}
-          {...common}
-          onClick={(data) => this.clickPoint(middle, 'middle', data)}
-        />
-        {circleLabelNode}
-
-        <BasePoint
-          disabled={building || disabled}
-          coordinatesOnHover={coordinatesOnHover}
-          correctness={correctness}
-          labelNode={labelNode}
-          x={to.x}
-          y={to.y}
-          onDrag={this.dragTo}
-          {...common}
-          onClick={(data) => this.clickPoint(to, 'to', data)}
-        />
-        {toLabelNode}
-
-        <BasePoint
-          disabled={building || disabled}
-          coordinatesOnHover={coordinatesOnHover}
-          correctness={correctness}
-          labelNode={labelNode}
-          x={from.x}
-          y={from.y}
-          className={classes.from}
-          onDrag={this.dragFrom}
-          {...common}
-          onClick={(data) => this.clickPoint(from, 'from', data)}
-        />
-        {fromLabelNode}
-      </g>
-    );
-  }
-}
-
-export const BaseCircle = withStyles(() => ({
-  outerLine: {
-    fill: 'rgb(0,0,0,0)', // TODO hardcoded color
-    stroke: color.defaults.PRIMARY_LIGHT,
-    strokeWidth: 4,
-    '&:hover': {
-      strokeWidth: 6,
-      stroke: color.defaults.PRIMARY_DARK,
-    },
-  },
-  root: {},
-  bgCircleBuilding: {
-    stroke: color.defaults.SECONDARY_LIGHT,
-    animation: 'opacityPulse 2s ease-out',
-    animationIterationCount: 'infinite',
-    opacity: 1,
-  },
-  '@keyframes opacityPulse': opacityPulsate('0.3'),
-}))(RawBaseCircle);
-
-const Component = rootEdgeComponent(BaseCircle);
-export default Component;

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/circle/index.js

@@ -1,25 +0,0 @@
-import Circle from './component';
-import { equalPoints } from '../../utils';
-
-export const tool = () => ({
-  type: 'circle',
-  Component: Circle,
-  hover: (point, mark) => {
-    return { ...mark, edge: point };
-  },
-  addPoint: (point, mark) => {
-    if (mark && equalPoints(mark.root, point)) {
-      return mark;
-    }
-
-    if (!mark) {
-      return {
-        type: 'circle',
-        root: point,
-        building: true,
-      };
-    } else {
-      return { ...mark, edge: point, building: false };
-    }
-  },
-});

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/exponential/component.jsx

@@ -1,23 +0,0 @@
-import debug from 'debug';
-import { buildDataPoints, exponentialFromTwoPoints } from '../../../graphing-utils';
-import { withRootEdge, rootEdgeComponent } from '../shared/line/with-root-edge';
-
-const log = debug('pie-lib:graphing:exponential');
-
-const Exponential = withRootEdge((props) => {
-  const { root, edge, graphProps } = props;
-  const { domain, range } = graphProps;
-
-  const dataPoints =
-    edge && edge.x === root.x
-      ? []
-      : buildDataPoints(domain, range, root, edge, exponentialFromTwoPoints(root, edge), true);
-
-  log('dataPoints:', dataPoints);
-
-  return { root: props.root, edge: props.edge, dataPoints };
-});
-
-const Component = rootEdgeComponent(Exponential);
-
-export default Component;

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/exponential/index.js

@@ -1,39 +0,0 @@
-import Exponential from './component';
-import debug from 'debug';
-import { equalPoints, sameAxes } from '../../utils';
-
-const log = debug('pie-lib:graphing:exponential');
-
-export const tool = () => ({
-  type: 'exponential',
-  Component: Exponential,
-  complete: (data, mark) => ({ ...mark, building: false, closed: true }),
-  addPoint: (point, mark) => {
-    log('add point to exponential model: ', point, 'mark: ', mark);
-    if (mark && (equalPoints(mark.root, point) || sameAxes(mark.root, point))) {
-      return mark;
-    }
-
-    if (mark && mark.root.y * point.y < 0) {
-      return mark;
-    }
-
-    if (point.y === 0) {
-      return mark;
-    }
-
-    if (!mark) {
-      return {
-        type: 'exponential',
-        root: point,
-        edge: undefined,
-        closed: false,
-        building: true,
-      };
-    } else if (mark && !mark.root) {
-      throw new Error('no root - should never happen');
-    } else {
-      return { ...mark, edge: point, closed: true, building: false };
-    }
-  },
-});

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/index.js

@@ -1,42 +0,0 @@
-import { tool as point } from './point';
-import { tool as circle } from './circle';
-import { tool as polygon } from './polygon';
-import { tool as sine } from './sine';
-import { tool as parabola } from './parabola';
-import { tool as line } from './line';
-import { tool as segment } from './segment';
-import { tool as ray } from './ray';
-import { tool as vector } from './vector';
-import { tool as absolute } from './absolute';
-import { tool as exponential } from './exponential';
-
-const allTools = [
-  'circle',
-  'line',
-  'label',
-  'parabola',
-  'point',
-  'polygon',
-  'ray',
-  'segment',
-  'sine',
-  'vector',
-  'absolute',
-  'exponential',
-];
-
-const toolsArr = [
-  circle(),
-  line(),
-  parabola(),
-  point(),
-  polygon(),
-  ray(),
-  segment(),
-  sine(),
-  vector(),
-  absolute(),
-  exponential(),
-];
-
-export { allTools, toolsArr, circle, line, point, parabola, polygon, ray, sine, vector, absolute, exponential };

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/line/component.jsx

@@ -1,70 +0,0 @@
-import { lineToolComponent, lineBase, styles } from '../shared/line';
-import React from 'react';
-import PropTypes from 'prop-types';
-import { trig, types } from '../../../plot';
-import classNames from 'classnames';
-import { withStyles } from '@material-ui/core/styles';
-import { ArrowMarker, genUid } from '../shared/arrow-head';
-import { thinnerShapesNeeded, getAdjustedGraphLimits } from '../../utils';
-
-const lineStyles = (theme) => ({
-  line: styles.line(theme),
-  enabledArrow: styles.arrow(theme),
-  disabledArrow: styles.disabledArrow(theme),
-  disabled: styles.disabled(theme),
-  correct: styles.correct(theme, 'stroke'),
-  correctArrow: styles.correct(theme),
-  incorrect: styles.incorrect(theme, 'stroke'),
-  incorrectArrow: styles.incorrect(theme),
-  missing: styles.missing(theme, 'stroke'),
-  missingArrow: styles.missing(theme),
-});
-
-export const ArrowedLine = (props) => {
-  const markerId = genUid();
-  const { className, classes, correctness, disabled, graphProps, from, to, ...rest } = props;
-  const { scale } = graphProps;
-  const { domain, range } = getAdjustedGraphLimits(graphProps);
-  const [eFrom, eTo] = trig.edges(domain, range)(from, to);
-  const suffix = correctness || (disabled && 'disabled') || 'enabled';
-
-  return (
-    <g>
-      <defs>
-        <ArrowMarker
-          size={thinnerShapesNeeded(graphProps) ? 4 : 5}
-          id={`${props.markerId || markerId}-${suffix}`}
-          className={classNames(classes[`${suffix}Arrow`])}
-        />
-      </defs>
-      <line
-        x1={scale.x(eFrom.x)}
-        y1={scale.y(eFrom.y)}
-        x2={scale.x(eTo.x)}
-        y2={scale.y(eTo.y)}
-        className={classNames(classes.line, disabled && classes.disabled, classes[correctness], className)}
-        markerEnd={`url(#${props.markerId || markerId}-${suffix})`}
-        markerStart={`url(#${props.markerId || markerId}-${suffix})`}
-        {...rest}
-      />
-    </g>
-  );
-};
-
-ArrowedLine.propTypes = {
-  className: PropTypes.string,
-  classes: PropTypes.object,
-  correctness: PropTypes.string,
-  disabled: PropTypes.bool,
-  graphProps: types.GraphPropsType,
-  from: types.PointType,
-  to: types.PointType,
-  markerId: PropTypes.string,
-};
-
-const StyledArrowedLine = withStyles(lineStyles)(ArrowedLine);
-
-const Line = lineBase(StyledArrowedLine);
-const Component = lineToolComponent(Line);
-
-export default Component;

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/line/index.js

@@ -1,4 +0,0 @@
-import Line from './component';
-import { lineTool } from '../shared/line';
-
-export const tool = lineTool('line', Line);

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/parabola/component.jsx

@@ -1,23 +0,0 @@
-import debug from 'debug';
-import { buildDataPoints, parabolaFromTwoPoints } from '../../../graphing-utils';
-import { withRootEdge, rootEdgeComponent } from '../shared/line/with-root-edge';
-
-const log = debug('pie-lib:graphing:parabola');
-
-const Parabola = withRootEdge((props) => {
-  const { root, edge, graphProps } = props;
-  const { domain, range } = graphProps;
-
-  const dataPoints =
-    edge && edge.x === root.x
-      ? []
-      : buildDataPoints(domain, range, root, edge, parabolaFromTwoPoints(root, edge), true);
-
-  log('dataPoints:', dataPoints);
-
-  return { root: props.root, edge: props.edge, dataPoints };
-});
-
-const Component = rootEdgeComponent(Parabola);
-
-export default Component;

package/controller/node_modules/@pie-lib/pie-toolbox/src/code/graphing/tools/parabola/index.js

@@ -1,31 +0,0 @@
-import Parabola from './component';
-import debug from 'debug';
-import { equalPoints, sameAxes } from '../../utils';
-
-const log = debug('pie-lib:graphing:parabola');
-
-export const tool = () => ({
-  type: 'parabola',
-  Component: Parabola,
-  complete: (data, mark) => ({ ...mark, building: false, closed: true }),
-  addPoint: (point, mark) => {
-    log('add point to parabola model: ', point, 'mark: ', mark);
-    if (mark && (equalPoints(mark.root, point) || sameAxes(mark.root, point))) {
-      return mark;
-    }
-
-    if (!mark) {
-      return {
-        type: 'parabola',
-        root: point,
-        edge: undefined,
-        closed: false,
-        building: true,
-      };
-    } else if (mark && !mark.root) {
-      throw new Error('no root - should never happen');
-    } else {
-      return { ...mark, edge: point, closed: true, building: false };
-    }
-  },
-});