nzk-react-components 0.4.5 → 0.4.6-2

package/dist/components/DrawingTool/lib/Sketch.js

@@ -1,414 +0,0 @@
-'use strict';
-
-var tslib = require('tslib');
-var after = require('lodash.after');
-var SketchLayer = require('./SketchLayer.js');
-var createInteractionSurface = require('./createInteractionSurface.js');
-var SketchModel = require('./SketchModel.js');
-var trace = require('./trace.js');
-var trimCanvas = require('./trimCanvas.js');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var after__default = /*#__PURE__*/_interopDefaultLegacy(after);
-
-var setDrawingStyle = function (style, ctx) {
-    if (style) {
-        var colour = "rgba(" + style.colour[0] + ", " + style.colour[1] + ", " + style.colour[2] + ", " + style.opacity + ")";
-        ctx.strokeStyle = colour;
-        ctx.fillStyle = colour;
-        ctx.lineWidth = style.size;
-    }
-    ctx.lineJoin = "round";
-    ctx.lineCap = "round";
-};
-var Sketch = (function () {
-    function Sketch(props) {
-        this.isDrawing = false;
-        this.containerEl = props.containerEl;
-        this.naturalWidth = props.containerEl.offsetWidth;
-        this.naturalHeight = props.containerEl.offsetHeight;
-        this.pixelRatioScale = window.devicePixelRatio > 1.5 ? 2 : 1;
-        this.width = this.naturalWidth * this.pixelRatioScale;
-        this.height = this.naturalHeight * this.pixelRatioScale;
-        this.template = props.template;
-        this.model = new SketchModel({
-            pixelRatioScale: this.pixelRatioScale
-        });
-        var defaultLayerProps = {
-            pixelRatioScale: this.pixelRatioScale,
-            width: props.containerEl.offsetWidth,
-            height: props.containerEl.offsetHeight
-        };
-        if (this.template) {
-            this.templateLayer = new SketchLayer(defaultLayerProps);
-            this.templateLayer.drawImageToFill(this.template);
-            this.containerEl.appendChild(this.templateLayer.canvas);
-        }
-        this.drawingLayer = new SketchLayer(defaultLayerProps);
-        this.drawingLayer.canvas.style.zIndex = '1';
-        this.containerEl.appendChild(this.drawingLayer.canvas);
-        this.bufferLayer = new SketchLayer(defaultLayerProps);
-        this.bufferLayer.canvas.style.zIndex = '2';
-        this.containerEl.appendChild(this.bufferLayer.canvas);
-        this.cacheLayer = new SketchLayer(defaultLayerProps);
-        this.cacheLayer.hide();
-        this.containerEl.appendChild(this.cacheLayer.canvas);
-        this.interactionSurface = createInteractionSurface({
-            width: this.containerEl.offsetWidth,
-            height: this.containerEl.offsetHeight,
-            scale: this.pixelRatioScale,
-            onTouchStart: this.startDraw.bind(this),
-            onTouchMove: this.continueDraw.bind(this),
-            onTouchEnd: this.endDraw.bind(this),
-            onTouchLeave: this.endDraw.bind(this),
-            onTouchEnter: this.startDraw.bind(this)
-        });
-        this.interactionSurface.style.zIndex = '100';
-        this.containerEl.appendChild(this.interactionSurface);
-        this.initDrawAnimations();
-        if (this.bufferLayer.ctx) {
-            setDrawingStyle(this.model.getStyle(), this.bufferLayer.ctx);
-        }
-        if (props.onChange)
-            this.onChange = props.onChange;
-        if (props.sketchData) {
-            this.deserialize(props.sketchData);
-            this.drawExistingSketch(props.onReady);
-        }
-        else if (props.onReady) {
-            props.onReady();
-        }
-    }
-    Sketch.prototype.setBrush = function (_a) {
-        var colour = _a.colour, size = _a.size, opacity = _a.opacity, fill = _a.fill, eraser = _a.eraser;
-        if (colour !== undefined) {
-            this.model.colour = colour;
-        }
-        if (size !== undefined) {
-            this.model.size = size;
-        }
-        if (opacity !== undefined) {
-            this.model.opacity = opacity;
-        }
-        if (fill !== undefined) {
-            this.model.fill = fill;
-        }
-        if (eraser !== undefined) {
-            this.model.eraser = eraser;
-        }
-    };
-    Sketch.prototype.mergeImage = function (data, saveAction, callback) {
-        var _this = this;
-        if (saveAction === void 0) { saveAction = true; }
-        if (callback === void 0) { callback = function () { }; }
-        var doMerge = function (img) {
-            var scale = (data.width / img.width) * _this.pixelRatioScale;
-            _this.drawingLayer.ctx.globalCompositeOperation = "source-over";
-            _this.drawingLayer.ctx.save();
-            _this.drawingLayer.ctx.translate(data.origin[0] * _this.pixelRatioScale, data.origin[1] * _this.pixelRatioScale);
-            _this.drawingLayer.ctx.rotate(data.rotation * Math.PI / 180);
-            _this.drawingLayer.ctx.translate(-data.x - img.width * scale / 2, -data.y - img.height * scale / 2);
-            _this.drawingLayer.ctx.drawImage(img, data.x, data.y, img.width * scale, img.height * scale);
-            _this.drawingLayer.ctx.restore();
-            if (saveAction) {
-                _this.model.saveMergeImage(data);
-                if (_this.onChange) {
-                    _this.onChange();
-                }
-            }
-            callback();
-        };
-        if (data.image) {
-            doMerge(data.image);
-        }
-        else if (data.imageSrc) {
-            var img_1 = new Image;
-            img_1.onload = function () { doMerge(img_1); };
-            img_1.src = data.imageSrc;
-        }
-    };
-    Sketch.prototype.export = function (props) {
-        if (this.templateLayer) {
-            this.templateLayer.drawImageToFit(this.drawingLayer.canvas);
-        }
-        var layerToExport = this.getLayerToExport();
-        var exportCanvas = (props && props.crop) ? trimCanvas(layerToExport.canvas) : layerToExport.canvas;
-        return exportCanvas.toDataURL();
-    };
-    Sketch.prototype.undo = function () {
-        if (!this.model.canUndo())
-            return;
-        this.model.lastActionIndex -= 1;
-        this.drawingLayer.clear();
-        console.log('Last action Index before undo', this.model.lastActionIndex);
-        for (var i = 0; i <= this.model.lastActionIndex; i += 1) {
-            console.log('I=', i);
-            if (this.model.actions[i].type === 'STROKE' && this.model.actions[i].model) {
-                console.log('draw stroke');
-                this.drawUndoStroke(this.model.actions[i].model);
-            }
-            else if (this.model.actions[i].type === 'IMAGE_MERGE' && this.model.actions[i]) {
-                console.log('merge image');
-                this.mergeImage(this.model.actions[i].data, false);
-            }
-        }
-        if (this.onChange)
-            this.onChange();
-    };
-    Sketch.prototype.redo = function () {
-        if (!this.model.canRedo())
-            return;
-        this.model.lastActionIndex += 1;
-        var action = this.model.actions[this.model.lastActionIndex];
-        if (action.type === 'STROKE' && action.model) {
-            this.drawUndoStroke(action.model);
-        }
-        else if (action.type === 'IMAGE_MERGE' && action.data) {
-            this.mergeImage(action.data, false);
-        }
-        if (this.onChange)
-            this.onChange();
-    };
-    Sketch.prototype.canUndo = function () {
-        return this.model.canUndo();
-    };
-    Sketch.prototype.canRedo = function () {
-        return this.model.canRedo();
-    };
-    Sketch.prototype.restart = function () {
-        this.model.reset();
-        this.drawingLayer.clear();
-        if (this.onChange) {
-            this.onChange();
-        }
-    };
-    Sketch.prototype.serialize = function () {
-        return this.model.serialize();
-    };
-    Sketch.prototype.deserialize = function (serialized) {
-        this.model.deserialize(serialized);
-    };
-    Sketch.prototype.getNumberOfActions = function () {
-        return this.model.lastActionIndex + 1;
-    };
-    Sketch.prototype.initDrawAnimations = function () {
-        this.drawUndo = {
-            transparentEraserFill: this.drawTransparentFillFinal,
-            transparentEraserStroke: this.drawStrokeFinal,
-            transparentColourFill: this.drawTransparentFillFinal,
-            transparentColourStroke: this.drawStrokeFinal,
-            opaqueEraserFill: this.drawEraserUndoingFillFinal,
-            opaqueEraserStroke: this.drawEraserUndoingFinal,
-            opaqueColourFill: this.drawFillFinal,
-            opaqueColourStroke: this.drawStrokeFinal
-        };
-        this.drawFinished = {
-            transparentEraserFill: this.drawTransparentFillFinal,
-            transparentEraserStroke: this.drawStrokeFinal,
-            transparentColourFill: this.drawTransparentFillFinal,
-            transparentColourStroke: this.drawStrokeFinal,
-            opaqueEraserFill: this.drawEraserFillFinal,
-            opaqueEraserStroke: this.drawEraser,
-            opaqueColourFill: this.drawFillFinal,
-            opaqueColourStroke: this.drawStrokeFinal
-        };
-        this.drawAnimation = {
-            transparentEraserFill: this.drawFillAndStroke,
-            transparentEraserStroke: this.drawFillAndStroke,
-            transparentColourFill: this.drawFillAndStroke,
-            transparentColourStroke: this.drawFillAndStroke,
-            opaqueEraserFill: this.drawEraser,
-            opaqueEraserStroke: this.drawEraser,
-            opaqueColourFill: this.drawFillAndStroke,
-            opaqueColourStroke: this.drawFillAndStroke
-        };
-    };
-    Sketch.prototype.startDraw = function (point) {
-        this.isDrawing = true;
-        this.model.initStroke(point);
-        if (this.model.currentStroke && this.model.currentStroke.style && this.cacheLayer.ctx && this.drawingLayer.ctx) {
-            if (this.model.currentStroke.style.eraser && this.model.currentStroke.style.opacity === 1.0) {
-                this.cacheLayer.ctx.globalCompositeOperation = "copy";
-                this.cacheLayer.ctx.drawImage(this.drawingLayer.ctx.canvas, 0, 0, this.width, this.height);
-                setDrawingStyle(this.model.currentStroke.style, this.drawingLayer.ctx);
-            }
-        }
-        if (this.model.currentStroke && this.bufferLayer.ctx) {
-            setDrawingStyle(this.model.currentStroke.style, this.bufferLayer.ctx);
-        }
-        this.strokeAnimation();
-    };
-    Sketch.prototype.continueDraw = function (point) {
-        if (!this.isDrawing)
-            return false;
-        this.model.continueStroke(point);
-        return false;
-    };
-    Sketch.prototype.endDraw = function () {
-        if (!(this.model.currentStroke && this.model.currentStroke.style))
-            return;
-        this.isDrawing = false;
-        this.endStrokeAnimation();
-        this.bufferLayer.clear();
-        this.drawFinishedStroke(this.model.currentStroke);
-        this.model.saveStroke();
-        if (this.onChange) {
-            this.onChange();
-        }
-    };
-    Sketch.prototype.drawExistingSketch = function (callback) {
-        if (this.model.lastActionIndex === -1) {
-            if (callback)
-                callback();
-            return;
-        }
-        var done = after__default['default'](Math.min(this.model.lastActionIndex, this.model.actions.length), function () {
-            if (callback)
-                callback();
-        });
-        for (var i = 0; i <= this.model.lastActionIndex; i += 1) {
-            this.drawAction(this.model.actions[i], done);
-        }
-    };
-    Sketch.prototype.drawAction = function (action, callback) {
-        if (callback === void 0) { callback = function () { }; }
-        if (action.type === 'STROKE' && action.model) {
-            this.drawExistingStroke(action.model);
-            callback();
-        }
-        else if (action.type === 'IMAGE_MERGE') {
-            this.mergeImage(action.data, false, callback);
-        }
-    };
-    Sketch.prototype.strokeAnimation = function () {
-        var _this = this;
-        this.drawAnimationStroke(this.model.currentStroke);
-        this.reqStroke = window.requestAnimationFrame(function () { return _this.strokeAnimation.apply(_this); });
-    };
-    Sketch.prototype.drawAnimationStroke = function (stroke) {
-        this.drawAnimation[stroke.style.type].apply(this, [stroke]);
-    };
-    Sketch.prototype.endStrokeAnimation = function () {
-        window.cancelAnimationFrame(this.reqStroke);
-        this.reqStroke = 0;
-    };
-    Sketch.prototype.drawUndoStroke = function (stroke) {
-        setDrawingStyle(stroke.style, this.drawingLayer.ctx);
-        this.drawUndo[stroke.style.type].apply(this, [stroke]);
-    };
-    Sketch.prototype.drawFinishedStroke = function (stroke) {
-        setDrawingStyle(stroke.style, this.drawingLayer.ctx);
-        this.drawFinished[stroke.style.type].apply(this, [stroke]);
-    };
-    Sketch.prototype.drawExistingStroke = function (stroke) {
-        setDrawingStyle(stroke.style, this.drawingLayer.ctx);
-        this.drawFinished[stroke.style.type].apply(this, [stroke, false]);
-    };
-    Sketch.prototype.drawTransparentFillFinal = function (stroke) {
-        this.cacheLayer.clear();
-        this.cacheLayer.ctx.globalCompositeOperation = "source-over";
-        setDrawingStyle(tslib.__assign(tslib.__assign({}, stroke.style), { opacity: 1 }), this.cacheLayer.ctx);
-        trace(stroke, this.cacheLayer.ctx);
-        this.cacheLayer.ctx.closePath();
-        this.cacheLayer.ctx.stroke();
-        this.cacheLayer.ctx.fill();
-        this.drawingLayer.ctx.globalCompositeOperation = "source-over";
-        this.drawingLayer.ctx.globalAlpha = stroke.style.opacity;
-        this.drawingLayer.ctx.drawImage(this.cacheLayer.ctx.canvas, 0, 0, this.width, this.height);
-        this.drawingLayer.ctx.globalAlpha = 1.0;
-    };
-    Sketch.prototype.drawStrokeFinal = function (stroke) {
-        this.drawingLayer.ctx.globalCompositeOperation = "source-over";
-        trace(stroke, this.drawingLayer.ctx);
-        this.drawingLayer.ctx.stroke();
-    };
-    Sketch.prototype.drawFillFinal = function (stroke) {
-        this.drawingLayer.ctx.globalCompositeOperation = "source-over";
-        trace(stroke, this.drawingLayer.ctx);
-        this.drawingLayer.ctx.closePath();
-        this.drawingLayer.ctx.fill();
-        this.drawingLayer.ctx.stroke();
-    };
-    Sketch.prototype.drawFillAndStroke = function (stroke) {
-        this.bufferLayer.clear();
-        trace(stroke, this.bufferLayer.ctx);
-        setDrawingStyle(tslib.__assign(tslib.__assign({}, stroke.style), { opacity: 1 }), this.bufferLayer.ctx);
-        this.bufferLayer.ctx.globalAlpha = stroke.style.opacity;
-        if (this.model.fill) {
-            this.bufferLayer.ctx.closePath();
-            this.bufferLayer.ctx.fill();
-        }
-        this.bufferLayer.ctx.stroke();
-    };
-    Sketch.prototype.drawEraserUndoingFinal = function (stroke) {
-        this.drawingLayer.ctx.globalCompositeOperation = "destination-out";
-        trace(stroke, this.drawingLayer.ctx);
-        this.drawingLayer.ctx.stroke();
-    };
-    Sketch.prototype.drawEraserUndoingFillFinal = function (stroke) {
-        this.drawingLayer.ctx.globalCompositeOperation = "destination-out";
-        trace(stroke, this.drawingLayer.ctx);
-        this.drawingLayer.ctx.closePath();
-        this.drawingLayer.ctx.fill();
-        this.drawingLayer.ctx.stroke();
-    };
-    Sketch.prototype.drawEraser = function (stroke, copy) {
-        if (copy === void 0) { copy = true; }
-        if (copy) {
-            this.drawingLayer.ctx.globalCompositeOperation = "copy";
-            this.drawingLayer.ctx.drawImage(this.cacheLayer.ctx.canvas, 0, 0, this.width, this.height);
-        }
-        this.drawingLayer.ctx.globalCompositeOperation = "destination-out";
-        trace(stroke, this.drawingLayer.ctx);
-        this.drawingLayer.ctx.stroke();
-    };
-    Sketch.prototype.drawEraserFillFinal = function (stroke, copy) {
-        if (copy === void 0) { copy = true; }
-        if (copy) {
-            this.drawingLayer.ctx.globalCompositeOperation = "copy";
-            this.drawingLayer.ctx.drawImage(this.cacheLayer.ctx.canvas, 0, 0, this.width, this.height);
-        }
-        this.drawingLayer.ctx.globalCompositeOperation = "destination-out";
-        trace(stroke, this.drawingLayer.ctx);
-        this.drawingLayer.ctx.closePath();
-        this.drawingLayer.ctx.fill();
-        this.drawingLayer.ctx.stroke();
-    };
-    Sketch.prototype.findBoundingBox = function (ctx) {
-        var imageData = ctx.getImageData(0, 0, this.width, this.height);
-        var box = {
-            topLeftX: this.width,
-            topLeftY: this.height,
-            bottomRightX: 0,
-            bottomRightY: 0,
-            width: 0,
-            height: 0
-        };
-        for (var x = 0; x < this.width; x += 1) {
-            for (var y = 0; y < this.height; y += 1) {
-                var pixelPosition = (((y * this.width) + x) * 4) + 3;
-                if (imageData.data[pixelPosition] > 0) {
-                    if (x < box.topLeftX)
-                        box.topLeftX = x;
-                    if (y < box.topLeftY)
-                        box.topLeftY = y;
-                    if (x > box.bottomRightX)
-                        box.bottomRightX = x;
-                    if (y > box.bottomRightY)
-                        box.bottomRightY = y;
-                }
-            }
-        }
-        box.width = box.bottomRightX - box.topLeftX;
-        box.height = box.bottomRightY - box.topLeftY;
-        return box;
-    };
-    Sketch.prototype.getLayerToExport = function () {
-        return this.templateLayer || this.drawingLayer;
-    };
-    return Sketch;
-}());
-
-module.exports = Sketch;
-//# sourceMappingURL=Sketch.js.map

package/dist/components/DrawingTool/lib/Sketch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Sketch.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/DrawingTool/lib/SketchCut.d.ts

@@ -1,22 +0,0 @@
-import Sketch, { SketchProps } from "./Sketch";
-import SketchCutModel from "./SketchCutModel";
-import SketchLayer from "./SketchLayer";
-import SketchStrokeModel from "./SketchStrokeModel";
-export interface SketchCutProps extends SketchProps {
-    imageToCut: HTMLImageElement;
-    onImageCut?: () => void;
-}
-export default class SketchCut extends Sketch {
-    readonly model: SketchCutModel;
-    readonly imageToCut: HTMLImageElement;
-    cutLayer: SketchLayer;
-    uiLayer: SketchLayer;
-    onImageCut?: () => void;
-    constructor(props: SketchCutProps);
-    initDrawAnimations(): void;
-    drawCutStroke(stroke: any): void;
-    drawCutFinal(stroke: any): void;
-    resetCut(): void;
-    drawOutline(stroke: SketchStrokeModel): void;
-    getLayerToExport(): SketchLayer;
-}

package/dist/components/DrawingTool/lib/SketchCut.js

@@ -1,98 +0,0 @@
-'use strict';
-
-var tslib = require('tslib');
-var Sketch = require('./Sketch.js');
-var SketchCutModel = require('./SketchCutModel.js');
-var SketchLayer = require('./SketchLayer.js');
-var trace = require('./trace.js');
-
-var SketchCut = (function (_super) {
-    tslib.__extends(SketchCut, _super);
-    function SketchCut(props) {
-        var _this = _super.call(this, props) || this;
-        _this.model = new SketchCutModel({
-            pixelRatioScale: _this.pixelRatioScale
-        });
-        _this.imageToCut = props.imageToCut;
-        _this.drawingLayer.drawImageToFit(_this.imageToCut, .9);
-        if (props.onImageCut) {
-            _this.onImageCut = props.onImageCut;
-        }
-        var defaultLayerProps = {
-            pixelRatioScale: _this.pixelRatioScale,
-            width: props.containerEl.offsetWidth,
-            height: props.containerEl.offsetHeight
-        };
-        _this.cutLayer = new SketchLayer(defaultLayerProps);
-        _this.cutLayer.canvas.style.zIndex = '1';
-        _this.containerEl.appendChild(_this.cutLayer.canvas);
-        _this.uiLayer = new SketchLayer(defaultLayerProps);
-        _this.uiLayer.canvas.style.zIndex = '4';
-        _this.containerEl.appendChild(_this.uiLayer.canvas);
-        return _this;
-    }
-    SketchCut.prototype.initDrawAnimations = function () {
-        _super.prototype.initDrawAnimations.call(this);
-        this.drawFinished.cut = this.drawCutFinal;
-        this.drawAnimation.cut = this.drawCutStroke;
-    };
-    SketchCut.prototype.drawCutStroke = function (stroke) {
-        this.bufferLayer.clear();
-        trace(stroke, this.bufferLayer.ctx);
-        this.bufferLayer.ctx.closePath();
-        this.bufferLayer.ctx.stroke();
-    };
-    SketchCut.prototype.drawCutFinal = function (stroke) {
-        this.bufferLayer.clear();
-        this.drawingLayer.ctx.globalCompositeOperation = 'copy';
-        this.drawingLayer.drawImageToFit(this.imageToCut);
-        this.drawingLayer.ctx.globalCompositeOperation = 'destination-in';
-        trace(stroke, this.drawingLayer.ctx);
-        this.drawingLayer.ctx.closePath();
-        this.drawingLayer.ctx.fill();
-        this.cutLayer.hide();
-        var box = this.findBoundingBox(this.drawingLayer.ctx);
-        if (box.width < 0 || box.height < 0 || (box.width * box.height) < ((this.width * this.height) * 0.001)) {
-            this.resetCut();
-        }
-        else {
-            this.drawOutline(stroke);
-            this.cutLayer.clear();
-            this.cutLayer.ctx.drawImage(this.drawingLayer.ctx.canvas, box.topLeftX, box.topLeftY, box.width, box.height, 0, 0, box.width, box.height);
-            if (this.onImageCut) {
-                this.onImageCut();
-            }
-        }
-    };
-    SketchCut.prototype.resetCut = function () {
-        this.uiLayer.clear();
-        this.drawingLayer.ctx.globalCompositeOperation = 'copy';
-        this.drawingLayer.drawImageToFit(this.imageToCut);
-    };
-    SketchCut.prototype.drawOutline = function (stroke) {
-        this.uiLayer.ctx.strokeStyle = "rgba(252,234,63, 1)";
-        this.uiLayer.ctx.lineWidth = 7 * this.pixelRatioScale;
-        this.uiLayer.ctx.lineJoin = "round";
-        this.uiLayer.ctx.lineCap = "round";
-        if (this.uiLayer.ctx.setLineDash) {
-            this.uiLayer.ctx.setLineDash([15]);
-        }
-        else if (this.uiLayer.ctx.webkitLineDash) {
-            this.uiLayer.ctx.webkitLineDash = [15, 15];
-        }
-        else {
-            this.uiLayer.ctx.mozDash = [15, 15];
-        }
-        this.uiLayer.clear();
-        trace(stroke, this.uiLayer.ctx);
-        this.uiLayer.ctx.closePath();
-        this.uiLayer.ctx.stroke();
-    };
-    SketchCut.prototype.getLayerToExport = function () {
-        return this.cutLayer;
-    };
-    return SketchCut;
-}(Sketch));
-
-module.exports = SketchCut;
-//# sourceMappingURL=SketchCut.js.map

package/dist/components/DrawingTool/lib/SketchCut.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SketchCut.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/components/DrawingTool/lib/SketchCutModel.d.ts

@@ -1,6 +0,0 @@
-import SketchModel from "./SketchModel";
-import { SketchStrokeType } from "./SketchStrokeModel";
-export default class SketchCutModel extends SketchModel {
-    colour: number[];
-    generateStyleType(): SketchStrokeType;
-}

package/dist/components/DrawingTool/lib/SketchCutModel.js

@@ -1,20 +0,0 @@
-'use strict';
-
-var tslib = require('tslib');
-var SketchModel = require('./SketchModel.js');
-
-var SketchCutModel = (function (_super) {
-    tslib.__extends(SketchCutModel, _super);
-    function SketchCutModel() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.colour = [252, 234, 63];
-        return _this;
-    }
-    SketchCutModel.prototype.generateStyleType = function () {
-        return 'cut';
-    };
-    return SketchCutModel;
-}(SketchModel));
-
-module.exports = SketchCutModel;
-//# sourceMappingURL=SketchCutModel.js.map

package/dist/components/DrawingTool/lib/SketchCutModel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SketchCutModel.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}

package/dist/components/DrawingTool/lib/SketchLayer.d.ts

@@ -1,27 +0,0 @@
-interface Props {
-    width: number;
-    height: number;
-    pixelRatioScale: number;
-    x?: number;
-    y?: number;
-}
-export default class SketchLayer {
-    width: number;
-    height: number;
-    x: number;
-    y: number;
-    naturalWidth: number;
-    naturalHeight: number;
-    readonly pixelRatioScale: number;
-    readonly canvas: HTMLCanvasElement;
-    readonly ctx: CanvasRenderingContext2D;
-    constructor(props: Props);
-    setSize(naturalWidth: any, naturalHeight: any, width: any, height: any): void;
-    setPosition(x: any, y: any): void;
-    hide(): void;
-    show(): void;
-    clear(): void;
-    drawImageToFit(image: any, ratio?: number): void;
-    drawImageToFill(image: any): void;
-}
-export {};

package/dist/components/DrawingTool/lib/SketchLayer.js

@@ -1,59 +0,0 @@
-'use strict';
-
-var SketchLayer = (function () {
-    function SketchLayer(props) {
-        this.x = 0;
-        this.y = 0;
-        this.pixelRatioScale = props.pixelRatioScale;
-        this.naturalWidth = props.width;
-        this.naturalHeight = props.height;
-        this.width = this.naturalWidth * this.pixelRatioScale;
-        this.height = this.naturalHeight * this.pixelRatioScale;
-        this.canvas = document.createElement('canvas');
-        this.ctx = this.canvas.getContext('2d');
-        this.canvas.style.position = 'absolute';
-        this.canvas.style.pointerEvents = 'none';
-        this.setSize(this.naturalWidth, this.naturalHeight, this.width, this.height);
-        if (props.x)
-            this.x = props.x;
-        if (props.y)
-            this.y = props.y;
-        this.setPosition(this.x, this.y);
-    }
-    SketchLayer.prototype.setSize = function (naturalWidth, naturalHeight, width, height) {
-        this.canvas.style.width = naturalWidth + "px";
-        this.canvas.style.height = naturalHeight + "px";
-        this.canvas.width = width;
-        this.canvas.height = height;
-    };
-    SketchLayer.prototype.setPosition = function (x, y) {
-        this.canvas.style.left = x + "px";
-        this.canvas.style.top = y + "px";
-    };
-    SketchLayer.prototype.hide = function () {
-        this.canvas.style.display = 'none';
-    };
-    SketchLayer.prototype.show = function () {
-        this.canvas.style.display = 'block';
-    };
-    SketchLayer.prototype.clear = function () {
-        this.ctx.clearRect(0, 0, this.width, this.height);
-    };
-    SketchLayer.prototype.drawImageToFit = function (image, ratio) {
-        if (ratio === void 0) { ratio = 1; }
-        var scale = Math.min(this.width / image.width, this.height / image.height) * ratio;
-        var x = (this.width / 2) - (image.width / 2) * scale;
-        var y = (this.height / 2) - (image.height / 2) * scale;
-        this.ctx.drawImage(image, 0, 0, image.width, image.height, x, y, image.width * scale, image.height * scale);
-    };
-    SketchLayer.prototype.drawImageToFill = function (image) {
-        var scale = Math.max(this.width / image.width, this.height / image.height);
-        var x = (this.width / 2) - (image.width / 2) * scale;
-        var y = (this.height / 2) - (image.height / 2) * scale;
-        this.ctx.drawImage(image, 0, 0, image.width, image.height, x, y, image.width * scale, image.height * scale);
-    };
-    return SketchLayer;
-}());
-
-module.exports = SketchLayer;
-//# sourceMappingURL=SketchLayer.js.map

package/dist/components/DrawingTool/lib/SketchLayer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SketchLayer.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}