@pie-lib/graphing 2.14.21 → 2.14.22-next.1618

package/src/tools/circle/__tests__/component.test.jsx

@@ -0,0 +1,228 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { graphProps, xy } from '../../../__tests__/utils';
+
+import { RawBaseCircle } from '../component';
+
+const xyLabel = (x, y, label) => ({ x, y, label });
+
+describe('Component', () => {
+  let w;
+  let onChange = jest.fn();
+  let changeMarkProps = jest.fn();
+
+  const wrapper = (extras) => {
+    const defaults = {
+      classes: {},
+      className: 'className',
+      onChange,
+      changeMarkProps,
+      graphProps: graphProps(),
+      from: xy(0, 0),
+      to: xy(1, 1),
+    };
+    const props = { ...defaults, ...extras };
+
+    return shallow(<RawBaseCircle {...props} />);
+  };
+
+  // used to test items that have labels attached to points
+  const labelNode = document.createElement('foreignObject');
+  const fromWithLabel = { x: 0, y: 0, label: 'A' };
+  const toWithLabel = { x: 1, y: 1, label: 'B' };
+  const wrapperWithLabels = (extras = {}) =>
+    wrapper({
+      ...extras,
+      labelNode: labelNode,
+      from: fromWithLabel,
+      to: toWithLabel,
+    });
+
+  describe('snapshot', () => {
+    it('renders', () => {
+      w = wrapper();
+      expect(w).toMatchSnapshot();
+    });
+
+    it('renders with labels', () => {
+      w = wrapperWithLabels();
+
+      expect(w).toMatchSnapshot();
+    });
+  });
+
+  describe('logic', () => {
+    beforeEach(() => (w = wrapper()));
+
+    describe('dragFrom', () => {
+      it('calls onChange', () => {
+        w = wrapper();
+        w.instance().dragFrom(xy(1, 1));
+        expect(onChange).not.toHaveBeenCalledWith({
+          from: xy(1, 1),
+          to: xy(1, 1),
+        });
+
+        w.instance().dragFrom(xy(2, 2));
+        expect(onChange).toHaveBeenCalledWith({
+          from: xy(2, 2),
+          to: xy(1, 1),
+        });
+      });
+    });
+
+    describe('dragFrom keeps labels on "from"', () => {
+      it('calls onChange', () => {
+        w = wrapperWithLabels();
+
+        // drag "from" to { x: 1, y: 1 }
+        w.instance().dragFrom({ x: 1, y: 1 });
+
+        // won't change because points overlap
+        expect(onChange).not.toHaveBeenCalledWith({
+          from: xyLabel(1, 1, 'A'),
+          to: toWithLabel,
+        });
+
+        // wil change and will keep labels
+        w.instance().dragFrom({ x: 2, y: 2 });
+        expect(onChange).toHaveBeenCalledWith({
+          from: xyLabel(2, 2, 'A'),
+          to: toWithLabel,
+        });
+      });
+    });
+
+    describe('dragTo', () => {
+      it('calls onChange', () => {
+        w.instance().dragTo(xy(4, 4));
+        expect(onChange).toHaveBeenCalledWith({
+          from: xy(0, 0),
+          to: xy(4, 4),
+        });
+      });
+    });
+
+    describe('dragTo keeps labels on "to"', () => {
+      it('calls onChange', () => {
+        w = wrapperWithLabels();
+
+        // won't change because points overlap
+        w.instance().dragTo({ x: 0, y: 0 });
+        expect(onChange).not.toHaveBeenCalledWith({
+          from: fromWithLabel,
+          to: xyLabel(1, 1, 'B'),
+        });
+
+        // wil change and will keep labels
+        w.instance().dragTo({ x: 2, y: 2 });
+        expect(onChange).toHaveBeenCalledWith({
+          from: fromWithLabel,
+          to: xyLabel(2, 2, 'B'),
+        });
+      });
+    });
+
+    describe('dragCircle', () => {
+      it('calls onChange', () => {
+        w.instance().dragCircle(xy(1, 1));
+        expect(onChange).toHaveBeenCalledWith({
+          from: xy(1, 1),
+          to: xy(2, 2),
+        });
+      });
+    });
+
+    describe('dragCircle keeps labels on both "from" and "to"', () => {
+      it('calls onChange', () => {
+        w = wrapperWithLabels();
+
+        // wil change and will keep labels
+        w.instance().dragCircle({ x: 10, y: 10 });
+        expect(onChange).toHaveBeenCalledWith({
+          from: xyLabel(10, 10, 'A'),
+          to: xyLabel(11, 11, 'B'),
+        });
+
+        // wil change and will keep labels
+        w.instance().dragCircle({ x: 2, y: 2 });
+        expect(onChange).toHaveBeenCalledWith({
+          from: xyLabel(2, 2, 'A'),
+          to: xyLabel(3, 3, 'B'),
+        });
+      });
+    });
+
+    describe('labelChange', () => {
+      it('updates "label" property for point', () => {
+        w = wrapperWithLabels({ labelModeEnabled: true });
+
+        w.instance().labelChange(xyLabel(0, 0, 'Label A'), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'Label A'),
+        });
+
+        w.instance().labelChange(xyLabel(0, 0, 'Label B'), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          to: xyLabel(0, 0, 'Label B'),
+        });
+      });
+
+      it('removes "label" property if the field is empty', () => {
+        w = wrapperWithLabels({ labelModeEnabled: true });
+
+        w.instance().labelChange(xyLabel(0, 0, ''), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xy(0, 0),
+        });
+
+        w.instance().labelChange(xyLabel(0, 0, ''), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          to: xy(0, 0),
+        });
+      });
+    });
+
+    describe('clickPoint', () => {
+      it('adds "label" property to a point', () => {
+        w = wrapperWithLabels({ labelModeEnabled: true });
+
+        w.instance().clickPoint(xy(0, 0), 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, ''),
+          to: xyLabel(1, 1, 'B'),
+        });
+
+        w.instance().clickPoint(xy(1, 1), 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'A'),
+          to: xyLabel(1, 1, ''),
+        });
+      });
+
+      it('adds "label" property to a point when limit labeling', () => {
+        const changeMarkProps = jest.fn();
+        w = wrapperWithLabels({ labelModeEnabled: true, limitLabeling: true, changeMarkProps });
+
+        w.instance().clickPoint(xy(0, 0), 'from');
+        expect(changeMarkProps).toHaveBeenCalledTimes(0);
+      });
+
+      it('if point already has label, keeps that value', () => {
+        w = wrapperWithLabels({ labelModeEnabled: true });
+
+        w.instance().clickPoint(fromWithLabel, 'from');
+        expect(changeMarkProps).toBeCalledWith({
+          from: fromWithLabel,
+          to: xyLabel(1, 1, 'B'),
+        });
+
+        w.instance().clickPoint(toWithLabel, 'to');
+        expect(changeMarkProps).toBeCalledWith({
+          from: xyLabel(0, 0, 'A'),
+          to: toWithLabel,
+        });
+      });
+    });
+  });
+});

package/src/tools/circle/bg-circle.jsx

@@ -5,7 +5,7 @@ import classNames from 'classnames';
 import { types, gridDraggable } from '@pie-lib/plot';
 import { color } from '@pie-lib/render-ui';
 import * as utils from '../../utils';
-import { disabled, correct, incorrect, missing } from '../shared/styles';
+import { disabled, disabledSecondary, correct, incorrect, missing } from '../shared/styles';
 
 /**
  * A low level circle component
@@ -33,7 +33,7 @@ class RawCircle extends React.Component {
 
     return (
       <ellipse
-        className={classNames(classes.bgCircle, disabled && classes.disabled, classes[correctness], className)}
+        className={classNames(classes.bgCircle, disabled && classes.disabledSecondary, classes[correctness], className)}
         cx={scale.x(x)}
         cy={scale.y(y)}
         rx={rx}
@@ -55,15 +55,16 @@ const applyStyle = (fn) => ({
 const styles = () => ({
   bgCircle: {
     fill: 'transparent',
-    stroke: color.primaryLight(),
+    stroke: color.defaults.BLACK,
     strokeWidth: 3,
     transition: 'stroke 200ms ease-in, stroke-width 200ms ease-in',
     '&:hover': {
       strokeWidth: 6,
-      stroke: color.primaryDark(),
+      stroke: color.defaults.PRIMARY_DARK,
     },
   },
   disabled: applyStyle(disabled),
+  disabledSecondary: applyStyle(disabledSecondary),
   correct: applyStyle(correct),
   incorrect: applyStyle(incorrect),
   missing: applyStyle(missing),

package/src/tools/circle/component.jsx

@@ -42,6 +42,7 @@ export class RawBaseCircle extends React.Component {
     labelNode: PropTypes.object,
     labelModeEnabled: PropTypes.bool,
     changeMarkProps: PropTypes.func,
+    limitLabeling: PropTypes.bool,
   };
 
   static defaultProps = {
@@ -128,8 +129,21 @@ export class RawBaseCircle extends React.Component {
     changeMarkProps({ [type]: update });
   };
 
-  clickPoint = (point, type) => {
-    const { changeMarkProps, from, to } = this.props;
+  clickPoint = (point, type, data) => {
+    const { changeMarkProps, disabled, from, to, labelModeEnabled, limitLabeling, onClick } = this.props;
+    if (!labelModeEnabled) {
+      onClick(point || data);
+      return;
+    }
+
+    if (disabled) {
+      return;
+    }
+
+    // limit labeling the points of the circle
+    if (limitLabeling) {
+      return;
+    }
 
     if (type === 'middle' && !point && from && to) {
       point = { ...point, ...getMiddleOfTwoPoints(from, to) };
@@ -224,7 +238,7 @@ export class RawBaseCircle extends React.Component {
           radius={radius}
           onDrag={this.dragCircle}
           {...common}
-          onClick={labelModeEnabled ? () => this.clickPoint(middle, 'middle') : common.onClick}
+          onClick={(data) => this.clickPoint(middle, 'middle', data)}
         />
         {circleLabelNode}
 
@@ -237,7 +251,7 @@ export class RawBaseCircle extends React.Component {
           y={to.y}
           onDrag={this.dragTo}
           {...common}
-          onClick={labelModeEnabled ? () => this.clickPoint(to, 'to') : common.onClick}
+          onClick={(data) => this.clickPoint(to, 'to', data)}
         />
         {toLabelNode}
 
@@ -251,7 +265,7 @@ export class RawBaseCircle extends React.Component {
           className={classes.from}
           onDrag={this.dragFrom}
           {...common}
-          onClick={labelModeEnabled ? () => this.clickPoint(from, 'from') : common.onClick}
+          onClick={(data) => this.clickPoint(from, 'from', data)}
         />
         {fromLabelNode}
       </g>
@@ -262,16 +276,16 @@ export class RawBaseCircle extends React.Component {
 export const BaseCircle = withStyles(() => ({
   outerLine: {
     fill: 'rgb(0,0,0,0)', // TODO hardcoded color
-    stroke: color.primaryLight(),
+    stroke: color.defaults.BLACK,
     strokeWidth: 4,
     '&:hover': {
       strokeWidth: 6,
-      stroke: color.primaryDark(),
+      stroke: color.defaults.PRIMARY_DARK,
     },
   },
   root: {},
   bgCircleBuilding: {
-    stroke: color.secondaryLight(),
+    stroke: color.defaults.BLACK,
     animation: 'opacityPulse 2s ease-out',
     animationIterationCount: 'infinite',
     opacity: 1,

package/src/tools/exponential/__tests__/component.test.jsx

@@ -0,0 +1,54 @@
+import React from 'react';
+import { withRootEdge } from '../../shared/line/with-root-edge';
+import { buildDataPoints, exponentialFromTwoPoints } from '@pie-lib/graphing-utils';
+import { utils } from '@pie-lib/plot';
+
+import { graphProps as getGraphProps } from '../../../__tests__/utils';
+
+const { xy } = utils;
+
+jest.mock('@pie-lib/graphing-utils', () => ({
+  buildDataPoints: jest.fn().mockReturnValue([]),
+  exponentialFromTwoPoints: jest.fn(() => jest.fn()),
+  getAmplitudeAndFreq: jest.fn().mockReturnValue({ freq: 4, amplitude: 1 }),
+}));
+
+jest.mock('../../shared/line/with-root-edge', () => ({
+  withRootEdge: jest.fn(),
+  rootEdgeComponent: jest.fn(),
+}));
+
+describe('Exponential', () => {
+  let fnBody;
+  let graphProps;
+  let root;
+  let edge;
+  let result;
+
+  beforeEach(() => {
+    require('../component');
+    fnBody = withRootEdge.mock.calls[0][0];
+    graphProps = getGraphProps();
+    root = xy(1, 1);
+    edge = xy(2, 2);
+
+    result = fnBody({ graphProps, root, edge });
+  });
+
+  it('fnBody is not null', () => {
+    expect(fnBody).toBeDefined();
+  });
+
+  it('calls buildDataPoints', () => {
+    const { domain, range } = graphProps;
+    expect(buildDataPoints).toHaveBeenCalledWith(domain, range, root, edge, expect.anything(), true);
+  });
+
+  it('calls exponentialFromTwoPoints', () => {
+    expect(exponentialFromTwoPoints).toHaveBeenCalledWith(root, edge);
+  });
+
+  it('returns dataPoints', () => {
+    expect(result).toEqual({ root, edge, dataPoints: [] });
+  });
+});

package/src/tools/exponential/component.jsx

@@ -0,0 +1,23 @@
+import debug from 'debug';
+import { buildDataPoints, exponentialFromTwoPoints } from '@pie-lib/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/src/tools/exponential/index.js

@@ -0,0 +1,39 @@
+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/src/tools/index.js

@@ -1,15 +1,48 @@
 import { tool as point } from './point';
 import { tool as circle } from './circle';
 import { tool as polygon } from './polygon';
-import { tool as sine } from './sine/index';
-import { tool as parabola } from './parabola/index';
+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'];
+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()];
+// need this because now we should treat label as other tools PD-3736
+const labelTool = {
+  type: 'label',
+};
 
-export { allTools, toolsArr, circle, line, point, parabola, polygon, ray, sine, vector };
+const toolsArr = [
+  circle(),
+  line(),
+  parabola(),
+  point(),
+  polygon(),
+  ray(),
+  segment(),
+  sine(),
+  vector(),
+  absolute(),
+  exponential(),
+  labelTool,
+];
+
+export { allTools, toolsArr, circle, line, point, parabola, polygon, ray, sine, vector, absolute, exponential };

package/src/tools/line/__tests__/__snapshots__/component.test.jsx.snap

@@ -0,0 +1,20 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`ArrowedLine snapshot renders 1`] = `
+<g>
+  <defs>
+    <ArrowMarker
+      className=""
+      id="1-enabled"
+      size={5}
+    />
+  </defs>
+  <line
+    className="className"
+    markerEnd="url(#1-enabled)"
+    markerId="1"
+    markerStart="url(#1-enabled)"
+    onChange={[MockFunction]}
+  />
+</g>
+`;

package/src/tools/line/__tests__/component.test.jsx

@@ -0,0 +1,36 @@
+import { shallow } from 'enzyme';
+import React from 'react';
+import { ArrowedLine } from '../component';
+import { graphProps as getGraphProps } from '../../../__tests__/utils';
+jest.mock('@pie-lib/plot', () => {
+  const a = jest.requireActual('@pie-lib/plot');
+  return {
+    types: a.types,
+    gridDraggable: a.gridDraggable,
+    utils: a.utils,
+    trig: {
+      edges: jest.fn(() => jest.fn().mockReturnValue([0, 0])),
+    },
+  };
+});
+
+describe('ArrowedLine', () => {
+  let w;
+  let onChange = jest.fn();
+  const wrapper = (extras) => {
+    const defaults = {
+      classes: {},
+      className: 'className',
+      onChange,
+      markerId: '1',
+      graphProps: getGraphProps(),
+    };
+    const props = { ...defaults, ...extras };
+    return shallow(<ArrowedLine {...props} />);
+  };
+  describe('snapshot', () => {
+    it('renders', () => {
+      expect(wrapper()).toMatchSnapshot();
+    });
+  });
+});

package/src/tools/line/component.jsx

@@ -12,6 +12,7 @@ const lineStyles = (theme) => ({
   enabledArrow: styles.arrow(theme),
   disabledArrow: styles.disabledArrow(theme),
   disabled: styles.disabled(theme),
+  disabledSecondary: styles.disabledSecondary(theme),
   correct: styles.correct(theme, 'stroke'),
   correctArrow: styles.correct(theme),
   incorrect: styles.incorrect(theme, 'stroke'),
@@ -42,7 +43,7 @@ export const ArrowedLine = (props) => {
         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)}
+        className={classNames(classes.line, disabled && classes.disabledSecondary, classes[correctness], className)}
         markerEnd={`url(#${props.markerId || markerId}-${suffix})`}
         markerStart={`url(#${props.markerId || markerId}-${suffix})`}
         {...rest}

package/src/tools/parabola/__tests__/component.test.jsx

@@ -0,0 +1,49 @@
+import React from 'react';
+import { withRootEdge } from '../../shared/line/with-root-edge';
+import { buildDataPoints, parabolaFromTwoPoints } from '@pie-lib/graphing-utils';
+import { utils } from '@pie-lib/plot';
+
+import { graphProps as getGraphProps } from '../../../__tests__/utils';
+
+const { xy } = utils;
+jest.mock('@pie-lib/graphing-utils', () => ({
+  buildDataPoints: jest.fn().mockReturnValue([]),
+  parabolaFromTwoPoints: jest.fn(() => jest.fn()),
+  getAmplitudeAndFreq: jest.fn().mockReturnValue({ freq: 4, amplitude: 1 }),
+}));
+
+jest.mock('../../shared/line/with-root-edge', () => ({
+  withRootEdge: jest.fn(),
+  rootEdgeComponent: jest.fn(),
+}));
+describe('Parabola', () => {
+  let fnBody;
+  let graphProps;
+  let root;
+  let edge;
+  let result;
+  beforeEach(() => {
+    require('../component');
+    fnBody = withRootEdge.mock.calls[0][0];
+    graphProps = getGraphProps();
+    root = xy(0, 0);
+    edge = xy(1, 1);
+
+    result = fnBody({ graphProps, root, edge });
+  });
+  it('fnBody is not null', () => {
+    expect(fnBody).toBeDefined();
+  });
+
+  it('calls buildDataPoints', () => {
+    const { domain, range } = graphProps;
+    expect(buildDataPoints).toHaveBeenCalledWith(domain, range, root, edge, expect.anything(), true);
+  });
+  it('calls parabolaFromTwoPoints', () => {
+    expect(parabolaFromTwoPoints).toHaveBeenCalledWith(root, edge);
+  });
+
+  it('returns dataPoints', () => {
+    expect(result).toEqual({ root, edge, dataPoints: [] });
+  });
+});

package/src/tools/parabola/component.jsx

@@ -2,21 +2,22 @@ import debug from 'debug';
 import { buildDataPoints, parabolaFromTwoPoints } from '@pie-lib/graphing-utils';
 import { withRootEdge, rootEdgeComponent } from '../shared/line/with-root-edge';
 
-const log = debug('pie-lib:graphing:sine');
+const log = debug('pie-lib:graphing:parabola');
 
 const Parabola = withRootEdge((props) => {
-  const { domain } = props.graphProps;
-
-  const { root, edge } = props;
-  const interval = 1;
+  const { root, edge, graphProps } = props;
+  const { domain, range } = graphProps;
 
   const dataPoints =
     edge && edge.x === root.x
       ? []
-      : buildDataPoints(domain.min, domain.max, root, edge, domain.step || interval, parabolaFromTwoPoints(root, edge));
+      : 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;