From 32db2a3c9a7113243ffb41f4c161c58c3c8d34c2 Mon Sep 17 00:00:00 2001 From: Garris Shpon Date: Mon, 24 Sep 2018 19:47:13 -0700 Subject: [PATCH] Squashed commit of the following: commit 02f09fde363fb15a46c89e4b88a5520c934e5219 Author: Garris Shpon Date: Mon Sep 24 14:07:23 2018 -0700 Linted! commit 32f3812e912e9c267dc62377ee1b7f4a0d2f23d7 Author: Garris Shpon Date: Sun Sep 23 22:20:17 2018 -0700 3.6.0 commit aa44bc6f6d387933d3e86f42d88326c97b472db1 Author: Garris Shpon Date: Sun Sep 23 22:19:40 2018 -0700 commented diverged button commit f20d97389d21468a28f416b588da3303fe93b39b Author: Garris Shpon Date: Sun Sep 23 22:12:19 2018 -0700 plumbing is in for divergedImage commit b953385e256b56eb4a3d60a4f0899f33f2ac5f65 Author: Garris Shpon Date: Sun Sep 23 00:51:48 2018 -0700 add back scrubber testImage src commit 65d66460c1bf870e123afd8c68e66d5542a49eda Author: Garris Shpon Date: Sun Sep 23 00:41:12 2018 -0700 3.5.15 commit 38f69751b06b4213b4d0539ddb57195350884343 Author: Garris Shpon Date: Sun Sep 23 00:39:43 2018 -0700 update usage commit ae5c1616ef21d0103ceeffcb45e16c5c82e581b2 Author: Garris Shpon Date: Sun Sep 23 00:32:28 2018 -0700 we have diverged commit 073b6ce22aa67e4f0f1fc5a3c099e4b2d2a81ae6 Author: Garris Shpon Date: Sun Sep 23 00:02:31 2018 -0700 backstop remote also clean up init cmd path commit d3a9bedc432f0d872581edd5096d5350294be04e Author: Garris Shpon Date: Sat Sep 22 10:51:47 2018 -0700 wip commit 50eec7839d06411b8d99b9572044270bb7fc3dbe Author: Garris Shpon Date: Fri Sep 21 23:43:15 2018 -0700 WIP commit d928ec88ce1050c7e23a6c18aed1485eda8e26fe Author: Garris Shpon Date: Fri Sep 21 15:58:16 2018 -0700 added backstop test to responsiveDemo --- cli/index.js | 6 - cli/usage.js | 5 +- compare/output/index_bundle.js | 2340 ++++++++++++++++- compare/src/actions/index.js | 7 + compare/src/components/atoms/ButtonFilter.js | 2 +- .../src/components/atoms/ButtonSettings.js | 2 +- compare/src/components/atoms/DiffDetails.js | 2 +- compare/src/components/atoms/ErrorMessages.js | 8 +- compare/src/components/atoms/IdContainer.js | 2 +- compare/src/components/atoms/ImagePreview.js | 14 +- compare/src/components/atoms/ImageScrubber.js | 123 +- .../src/components/atoms/InputTextSearch.js | 2 +- compare/src/components/atoms/Logo.js | 2 +- compare/src/components/atoms/NavButtons.js | 8 +- compare/src/components/atoms/SettingOption.js | 2 +- compare/src/components/atoms/SuiteName.js | 2 +- compare/src/components/atoms/TextDetails.js | 8 +- compare/src/components/atoms/UrlDetails.js | 2 +- compare/src/components/ecosystems/Header.js | 2 +- compare/src/components/ecosystems/List.js | 2 +- .../components/ecosystems/ScrubberModal.js | 24 +- .../src/components/molecules/FiltersSwitch.js | 6 +- .../components/molecules/ScrubberButton.js | 8 +- .../components/molecules/SettingsContainer.js | 6 +- .../src/components/molecules/SettingsPopup.js | 8 +- .../src/components/molecules/TestImages.js | 6 +- .../src/components/molecules/TextSearch.js | 6 +- compare/src/components/organisms/TestCard.js | 3 +- compare/src/components/organisms/Toolbar.js | 4 +- compare/src/components/organisms/Topbar.js | 2 +- compare/src/reducers/scrubber.js | 52 +- core/command/index.js | 6 +- core/command/{genConfig.js => init.js} | 5 +- core/command/openReport.js | 38 +- core/command/remote.js | 23 + core/runner.js | 49 + core/util/makeConfig.js | 2 +- examples/myCoolProject/readme.md | 2 +- examples/responsiveDemo/backstop.json | 54 + ...BackstopJS_Homepage_0_document_0_phone.png | Bin 0 -> 118187 bytes ...ackstopJS_Homepage_0_document_1_tablet.png | Bin 0 -> 115229 bytes .../casper/clickAndHoverHelper.js | 25 + .../engine_scripts/casper/loadCookies.js | 15 + .../engine_scripts/casper/onBefore.js | 4 + .../engine_scripts/casper/onReady.js | 5 + .../casper/waitForHelperHelper.js | 18 + .../chromy/clickAndHoverHelper.js | 34 + .../engine_scripts/chromy/loadCookies.js | 22 + .../engine_scripts/chromy/onBefore.js | 6 + .../engine_scripts/chromy/onReady.js | 5 + .../backstop_data/engine_scripts/cookies.json | 14 + .../engine_scripts/imageStub.jpg | Bin 0 -> 2900 bytes .../puppet/clickAndHoverHelper.js | 31 + .../engine_scripts/puppet/ignoreCSP.js | 65 + .../engine_scripts/puppet/interceptImages.js | 37 + .../engine_scripts/puppet/loadCookies.js | 29 + .../engine_scripts/puppet/onBefore.js | 3 + .../engine_scripts/puppet/onReady.js | 6 + examples/responsiveDemo/index.html | 3 + examples/responsiveDemo/package-lock.json | 381 +++ examples/responsiveDemo/package.json | 15 + examples/responsiveDemo/readme.md | 11 + package-lock.json | 294 ++- package.json | 4 +- ...BackstopJS_Homepage_0_document_0_phone.png | Bin 0 -> 131193 bytes ...ackstopJS_Homepage_0_document_1_tablet.png | Bin 0 -> 387695 bytes ...emoPage_comparePage_0_document_0_phone.png | Bin 0 -> 118258 bytes ...moPage_comparePage_0_document_1_tablet.png | Bin 0 -> 115276 bytes test/configs/responsiveTest.json | 53 + test/core/util/makeConfig_spec.js | 4 +- 70 files changed, 3698 insertions(+), 231 deletions(-) rename core/command/{genConfig.js => init.js} (92%) create mode 100644 core/command/remote.js create mode 100644 examples/responsiveDemo/backstop.json create mode 100644 examples/responsiveDemo/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_0_phone.png create mode 100644 examples/responsiveDemo/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_1_tablet.png create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/casper/clickAndHoverHelper.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/casper/loadCookies.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/casper/onBefore.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/casper/onReady.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/casper/waitForHelperHelper.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/chromy/clickAndHoverHelper.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/chromy/loadCookies.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/chromy/onBefore.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/chromy/onReady.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/cookies.json create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/imageStub.jpg create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/puppet/clickAndHoverHelper.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/puppet/ignoreCSP.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/puppet/interceptImages.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/puppet/loadCookies.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/puppet/onBefore.js create mode 100644 examples/responsiveDemo/backstop_data/engine_scripts/puppet/onReady.js create mode 100644 examples/responsiveDemo/package-lock.json create mode 100644 examples/responsiveDemo/package.json create mode 100644 examples/responsiveDemo/readme.md create mode 100644 test/configs/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_0_phone.png create mode 100644 test/configs/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_1_tablet.png create mode 100644 test/configs/backstop_data/bitmaps_reference/responsiveDemoPage_comparePage_0_document_0_phone.png create mode 100644 test/configs/backstop_data/bitmaps_reference/responsiveDemoPage_comparePage_0_document_1_tablet.png create mode 100644 test/configs/responsiveTest.json diff --git a/cli/index.js b/cli/index.js index 12447ad98..20085cc16 100755 --- a/cli/index.js +++ b/cli/index.js @@ -30,12 +30,6 @@ if (argsOptions.v || argsOptions.version) { var commandName = argsOptions['_'][0]; -if (/^init$/i.test(commandName)) { - commandName = 'genConfig'; -} - -// TODO: need command for: `pkill -f "(chrome)?(--headless)"` - if (!commandName) { console.log(usage); process.exit(); diff --git a/cli/usage.js b/cli/usage.js index f07f47644..d7baecb63 100644 --- a/cli/usage.js +++ b/cli/usage.js @@ -6,13 +6,16 @@ var commandsDescription = { approve: 'Promotes all test bitmaps from last test run to reference bitmaps.', reference: 'Creates new reference screenshots. Deletes all existing reference files.', init: 'Generate BackstopJS boilerplate files in your CWD. NOTE: Overwrites existing config files!', + remote: 'Launch BackstopJS remote service.', openReport: 'View the last test report in your browser.' }; var optionsDescription = { + '--config': 'Path to config file name', + '--filter': 'A RegEx string used to filter by scenario labels when running "test" or "approve" commands', '-h, --help': 'Display usage', '-v, --version': 'Display version', - '-i': 'incremental reference generation' + '-i': 'Prevent deletion of non-matching reference files when running "reference" command (newer matching reference files are still overwritten)' }; function makeDescription (descriptions) { diff --git a/compare/output/index_bundle.js b/compare/output/index_bundle.js index a06ff6c54..bcd3bd177 100644 --- a/compare/output/index_bundle.js +++ b/compare/output/index_bundle.js @@ -4837,6 +4837,13 @@ var showScrubberDiffImage = exports.showScrubberDiffImage = function showScrubbe }; }; +var showScrubberDivergedImage = exports.showScrubberDivergedImage = function showScrubberDivergedImage(value) { + return { + type: 'SHOW_SCRUBBER_DIVERGED_IMAGE', + value: value + }; +}; + var showScrubber = exports.showScrubber = function showScrubber(value) { return { type: 'SHOW_SCRUBBER', @@ -27341,13 +27348,26 @@ Object.defineProperty(exports, "__esModule", { function getPosFromImgId(imgId) { switch (imgId) { case 'refImage': - return 100; + return 105; //just passed the right border + case 'testImage': + return -1; //just passed the left border + case 'diffImage': + return -1; //just passed the left border + default: + return 50; //in the middle + } +} + +function getModeFromImgId(imgId) { + switch (imgId) { + case 'refImage': + return 'SHOW_SCRUBBER_REF_IMAGE'; case 'testImage': - return 0; + return 'SHOW_SCRUBBER_TEST_IMAGE'; case 'diffImage': - return -1; + return 'SHOW_SCRUBBER_DIFF_IMAGE'; default: - return 50; + return 'SCRUB'; } } @@ -27362,10 +27382,17 @@ var scrubber = function scrubber() { targetImgId = action.value.targetImg.id; } catch (err) {} + var scrubberModalMode = ''; + try { + scrubberModalMode = action.value.targetImg.id; + } catch (err) {} + return Object.assign({}, state, { position: getPosFromImgId(targetImgId), visible: true, - test: action.value + test: action.value, + testImageType: targetImgId, + scrubberModalMode: getModeFromImgId(targetImgId) }); case 'CLOSE_SCRUBBER_MODAL': @@ -27376,22 +27403,36 @@ var scrubber = function scrubber() { case 'SHOW_SCRUBBER_TEST_IMAGE': return Object.assign({}, state, { - position: getPosFromImgId('testImage') + position: getPosFromImgId('testImage'), + scrubberModalMode: action.type, + testImageType: 'testImage' }); case 'SHOW_SCRUBBER_REF_IMAGE': return Object.assign({}, state, { - position: getPosFromImgId('refImage') + position: getPosFromImgId('refImage'), + scrubberModalMode: action.type }); case 'SHOW_SCRUBBER_DIFF_IMAGE': return Object.assign({}, state, { - position: getPosFromImgId('diffImage') + position: getPosFromImgId('diffImage'), + scrubberModalMode: action.type, + testImageType: 'diffImage' + }); + + case 'SHOW_SCRUBBER_DIVERGED_IMAGE': + return Object.assign({}, state, { + position: getPosFromImgId('diffImage'), + scrubberModalMode: action.type, + testImageType: 'divergedImage', + test: Object.assign({}, state.test, { divergedImage: action.value }) }); case 'SHOW_SCRUBBER': return Object.assign({}, state, { - position: getPosFromImgId() + position: getPosFromImgId(), + scrubberModalMode: 'SCRUB' }); default: @@ -31014,7 +31055,6 @@ var TestCard = function (_React$Component) { { id: this.props.id, status: status }, !onlyText && _react2.default.createElement(_NavButtons2.default, { currentId: this.props.numId, lastId: this.props.lastId }), _react2.default.createElement(_TextDetails2.default, { info: info }), - _react2.default.createElement(_ScrubberButton2.default, { info: info, onlyText: onlyText }), _react2.default.createElement(_TestImages2.default, { info: info, status: status }), _react2.default.createElement(_ErrorMessages2.default, { info: info, status: status }) ); @@ -32496,16 +32536,20 @@ var ScrubberModal = function (_React$Component) { var _props$scrubber$test = this.props.scrubber.test, refImage = _props$scrubber$test.reference, testImage = _props$scrubber$test.test, - diffImage = _props$scrubber$test.diffImage; + diffImage = _props$scrubber$test.diffImage, + divergedImage = _props$scrubber$test.divergedImage; var _props$scrubber = this.props.scrubber, visible = _props$scrubber.visible, mode = _props$scrubber.mode, - position = _props$scrubber.position; + position = _props$scrubber.position, + testImageType = _props$scrubber.testImageType, + scrubberModalMode = _props$scrubber.scrubberModalMode; var _props = this.props, closeModal = _props.closeModal, showScrubberTestImage = _props.showScrubberTestImage, showScrubberRefImage = _props.showScrubberRefImage, showScrubberDiffImage = _props.showScrubberDiffImage, + showScrubberDivergedImage = _props.showScrubberDivergedImage, showScrubber = _props.showScrubber; @@ -32528,14 +32572,18 @@ var ScrubberModal = function (_React$Component) { _react2.default.createElement(ButtonClose, { onClick: closeModal }) ), _react2.default.createElement(_ImageScrubber2.default, { + scrubberModalMode: scrubberModalMode, + testImageType: testImageType, testImage: testImage, refImage: refImage, diffImage: diffImage, + divergedImage: divergedImage, position: position, showButtons: diffImage && diffImage.length > 0, showScrubberTestImage: showScrubberTestImage, showScrubberRefImage: showScrubberRefImage, showScrubberDiffImage: showScrubberDiffImage, + showScrubberDivergedImage: showScrubberDivergedImage, showScrubber: showScrubber }) ) @@ -32566,6 +32614,9 @@ var mapDispatchToProps = function mapDispatchToProps(dispatch) { showScrubberDiffImage: function showScrubberDiffImage(val) { dispatch((0, _actions.showScrubberDiffImage)(val)); }, + showScrubberDivergedImage: function showScrubberDivergedImage(val) { + dispatch((0, _actions.showScrubberDivergedImage)(val)); + }, showScrubber: function showScrubber(val) { dispatch((0, _actions.showScrubber)(val)); } @@ -33625,6 +33676,10 @@ var _backstopTwentytwenty2 = _interopRequireDefault(_backstopTwentytwenty); var _styles = __webpack_require__(6); +var _diverged = __webpack_require__(296); + +var _diverged2 = _interopRequireDefault(_diverged); + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } @@ -33679,20 +33734,54 @@ var ImageScrubber = function (_React$Component) { }, { key: 'render', value: function render() { + console.log('ImageScrubber PROPS>>>', this.props); var _props = this.props, + scrubberModalMode = _props.scrubberModalMode, + testImageType = _props.testImageType, position = _props.position, refImage = _props.refImage, testImage = _props.testImage, diffImage = _props.diffImage, + divergedImage = _props.divergedImage, showButtons = _props.showButtons, showScrubberTestImage = _props.showScrubberTestImage, showScrubberRefImage = _props.showScrubberRefImage, showScrubberDiffImage = _props.showScrubberDiffImage, + showScrubberDivergedImage = _props.showScrubberDivergedImage, showScrubber = _props.showScrubber; - var dontUseScrubberView = this.state.dontUseScrubberView || !showButtons; + var scrubberTestImageSlug = this.props[testImageType]; + + function getDiverged(arg) { + if (divergedImage) { + showScrubberDivergedImage(divergedImage); + return; + } + + var refImg = document.images.scrubberRefImage; + var testImg = document.images.isolatedTestImage; + + var h = refImg.height; + var w = refImg.width; + var refCtx = imageToCanvasContext(refImg); + var testCtx = imageToCanvasContext(testImg); + + console.log('starting diverged>>', new Date()); + var divergedImgData = (0, _diverged2.default)(getImgDataDataFromContext(refCtx), getImgDataDataFromContext(testCtx), h, w); + + var clampedImgData = getEmptyImgData(h, w); + for (var i = divergedImgData.length - 1; i >= 0; i--) { + clampedImgData.data[i] = divergedImgData[i]; + } + var lcsDiffResult = imageToCanvasContext(null, w, h); + lcsDiffResult.putImageData(clampedImgData, 0, 0); + var divergedImageResult = lcsDiffResult.canvas.toDataURL("image/png"); + showScrubberDivergedImage(divergedImageResult); + } + + var dontUseScrubberView = this.state.dontUseScrubberView || !showButtons; return _react2.default.createElement( Wrapper, null, @@ -33705,46 +33794,39 @@ var ImageScrubber = function (_React$Component) { _react2.default.createElement( ScrubberViewBtn, { - selected: position === 100, - onClick: function onClick() { - showScrubberRefImage(); - } + selected: scrubberModalMode === 'SHOW_SCRUBBER_REF_IMAGE', + onClick: showScrubberRefImage }, 'REFERENCE' ), _react2.default.createElement( ScrubberViewBtn, { - selected: position === 0, - onClick: function onClick() { - showScrubberTestImage(); - } + selected: scrubberModalMode === 'SHOW_SCRUBBER_TEST_IMAGE', + onClick: showScrubberTestImage }, 'TEST' ), _react2.default.createElement( ScrubberViewBtn, { - selected: position === -1, - onClick: function onClick() { - showScrubberDiffImage(); - } + selected: scrubberModalMode === 'SHOW_SCRUBBER_DIFF_IMAGE', + onClick: showScrubberDiffImage }, 'DIFF' ), _react2.default.createElement( ScrubberViewBtn, { - selected: position !== 100 && position !== 0 && position !== -1, - onClick: function onClick() { - showScrubber(); - } + selected: scrubberModalMode === 'SCRUB', + onClick: showScrubber }, 'SCRUBBER' ) ) ), _react2.default.createElement('img', { + id: 'isolatedTestImage', className: 'testImage', src: testImage, style: { @@ -33777,11 +33859,16 @@ var ImageScrubber = function (_React$Component) { newPosition: position }, _react2.default.createElement('img', { + id: 'scrubberRefImage', className: 'refImage', src: refImage, onError: this.handleLoadingError }), - _react2.default.createElement('img', { className: 'testImage', src: position === -1 ? diffImage : testImage }), + _react2.default.createElement('img', { + id: 'scrubberTestImage', + className: 'testImage', + src: scrubberTestImageSlug + }), _react2.default.createElement(SliderBar, { className: 'slider' }) ) ) @@ -33792,17 +33879,35 @@ var ImageScrubber = function (_React$Component) { return ImageScrubber; }(_react2.default.Component); -// const mapStateToProps = state => { -// console.log('map state>>>',state) -// return { -// test_: state -// }; -// }; - -// const ImageScrubberContainer = connect(mapStateToProps)(ImageScrubber); +/** + * ========= DIVERGED HELPERS ======== + */ exports.default = ImageScrubber; +function getImgDataDataFromContext(context) { + return context.getImageData(0, 0, context.canvas.width, context.canvas.height).data; +} + +function getEmptyImgData(h, w) { + var o = imageToCanvasContext(null, h, w); + return o.createImageData(w, h); +} + +function imageToCanvasContext(_img, w, h) { + var img = _img; + if (!_img) { + img = { width: w, height: h }; + } + var canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + var context = canvas.getContext("2d"); + if (_img) { + context.drawImage(img, 0, 0); + } + return context; +} /***/ }), /* 295 */ @@ -34054,5 +34159,2164 @@ TwentyTwenty.defaultProps = { }; +/***/ }), +/* 296 */ +/***/ (function(module, exports, __webpack_require__) { + +"use strict"; + + +let MEYERS_DIFF_ARRAY_METHOD = undefined; +// debugger +if (true) { + MEYERS_DIFF_ARRAY_METHOD = __webpack_require__(297).diffArrays; +} else { + MEYERS_DIFF_ARRAY_METHOD = JsDiff.diffArrays; +} + +const spread = 50; // range of adjacent pixels to aggregate when calculating diff +const IS_ADDED_WORD = '0_255_0_255'; +const IS_REMOVED_WORD = '255_0_0_255'; +const IS_ADDED_AND_REMOVED_WORD = '0_255_255_255'; +const IS_SAME_WORD = '255_255_255_255'; + +/** + * Applies meyers-diff algorithm to imageData formatted arrays + * + * @param {Uint8ClampedArray} [reference] baseline image + * @param {Uint8ClampedArray} [test] test image + * + * @returns {Uint8ClampedArray} diff image + * + */ +if (true) { + module.exports = diverged; +} + +function diverged(reference, test, h, w) { + console.time("diverged_total_time"); + + const spread = Math.floor(h / 80); //override + + console.log('spread:', spread); + + console.time("imgDataToWords"); + const img1wordArr = imgDataToWords(reference); + const img2wordArr = imgDataToWords(test); + console.timeEnd("imgDataToWords"); + + console.time("imgDataWordArrToColsAndRows"); + let cols_rows_ref = imgDataWordArrToColsAndRows(img1wordArr, h, w); + let cols_rows_test = imgDataWordArrToColsAndRows(img2wordArr, h, w); + console.timeEnd("imgDataWordArrToColsAndRows"); + + console.time("groupAdjacent"); + const columnRef = groupAdjacent(cols_rows_ref.columns, spread, h, w); + const columnTest = groupAdjacent(cols_rows_test.columns, spread, h, w); + console.timeEnd("groupAdjacent"); + + console.time("columnDiffRaw"); + const columnDiffRaw = diffArr(columnRef, columnTest, h, w); + console.timeEnd("columnDiffRaw"); + + console.time("reduceColumnDiffRaw"); + const reducedColumnDiff = reduceColumnDiffRaw(columnDiffRaw, h, w); + console.timeEnd("reduceColumnDiffRaw"); + // console.log("reducedColumnDiff>>>", reducedColumnDiff); + + console.time("unGroupAdjacent"); + const expandedColumns = ungroupAdjacent(reducedColumnDiff, spread, h, w); + console.timeEnd("unGroupAdjacent"); + + console.time("columnWordDataToImgDataFormatAsWords"); + const convertedColumnDiffImgData = columnWordDataToImgDataFormatAsWords(expandedColumns, h, w); + console.timeEnd("columnWordDataToImgDataFormatAsWords"); + // console.log("convertedColumnDiffImgData>>>", convertedColumnDiffImgData); + + console.time("imgDataWordsToClampedImgData"); + const imgDataArr = convertImgDataWordsToClampedImgData(convertedColumnDiffImgData); + console.timeEnd("imgDataWordsToClampedImgData"); + // console.log("imgDataArr>>>", imgDataArr); + + console.timeEnd("diverged_total_time"); + return imgDataArr; +} + +/** + * ========= HELPERS ======== + */ + +function columnWordDataToImgDataFormatAsWords(columns, h, w) { + const imgDataWordsLength = w * h; + + let convertedArr = new Array(imgDataWordsLength); + for (var i = 0; i < imgDataWordsLength; i++) { + const {column, depth} = serialToColumnMap(i, h, w); + convertedArr[i] = columns[column][depth]; + } + return convertedArr; +} + +function convertImgDataWordsToClampedImgData(wordsArr) { + let convertedArr = new Uint8ClampedArray(wordsArr.length * 4); + for (var i = 0; i < wordsArr.length; i++) { + const convertedOffset = i * 4; + const segments = wordsArr[i].split('_'); + convertedArr[convertedOffset] = segments[0]; + convertedArr[convertedOffset+1] = segments[1]; + convertedArr[convertedOffset+2] = segments[2]; + convertedArr[convertedOffset+3] = segments[3]; + } + return convertedArr; +} + +function reduceColumnDiffRaw(columnDiffs, h, w) { + let reducedColumns = new Array(columnDiffs.length); + for (let columnIndex = 0; columnIndex < columnDiffs.length; columnIndex++) { + const columnDiff = columnDiffs[columnIndex]; + let resultColumn = new Array(); + let removedCounter = 0; + let resultClass = ''; + + for (let depthIndex = 0; depthIndex < h; depthIndex++) { + let segmentLength = 0; + + if (columnDiff[depthIndex].removed) { + segmentLength = columnDiff[depthIndex].count; + removedCounter += segmentLength; + resultClass = IS_REMOVED_WORD; + } else { + if (columnDiff[depthIndex].added) { + if (removedCounter) { + resultClass = IS_ADDED_AND_REMOVED_WORD; + } else { + resultClass = IS_ADDED_WORD; + } + } else { + resultClass = IS_SAME_WORD; + } + + + segmentLength = columnDiff[depthIndex].count; + + if (removedCounter > 0) { + if (segmentLength > removedCounter) { + segmentLength -= removedCounter; + removedCounter = 0; + } else { + removedCounter -= segmentLength; + segmentLength = 0; + } + } + } + + if (!segmentLength) { + continue; + } else { + segmentLength = Math.min(segmentLength, h - resultColumn.length); + } + + let segment = new Array(segmentLength).fill(resultClass); + + // // Uncomment this to see a rough image representation + // let segment = columnDiff[depthIndex].value.slice(0,segmentLength).map((value) => { + // if (/|/.test(value)) + // return value.split('|')[0]; + // return value; + // }); + + resultColumn = resultColumn.concat(segment); + + if (resultColumn.length > h) { + console.log('WARNING -- this value is out of bounds!') + } + + if (resultColumn.length === h) { + break; + } + } + + reducedColumns[columnIndex] = resultColumn; + } + + return reducedColumns; +} + +function diffArr(refArr, testArr, h, w) { + let rawResultArr = []; + for (let i = 0; i < refArr.length; i++) { + rawResultArr.push(MEYERS_DIFF_ARRAY_METHOD(refArr[i], testArr[i])); + } + return rawResultArr; +} + +function groupAdjacent(columns, spread, h, w) { + if (!spread) { + return columns; + } + /** + * [getAdjacentArrayBounds retuns existing adjacent lower and upper column bounds] + * @param {[int]} pointer [current index] + * @param {[int]} spread [distance from index] + * @param {[int]} length [total length] + * @return {[array]} [0] lower bound, [1] upper bound + */ + function getAdjacentArrayBounds(pointer, spread, length) { + return [ + // Math.max(0, pointer - spread), + Math.max(0, pointer), + Math.min(length - 1, pointer + spread) + ] + } + + function getInterpolatedSequence(beginning, end) { + const interpolated = []; + for (let step = beginning; step <= end; step++) { + interpolated.push(step); + } + return interpolated; + } + + function getCompositeColumnDepthValues(columns, range, depth) { + return range.reduce((acc, column) => { + return acc.concat(columns[column][depth]); + }, []) + } + + const interpolatedColumnsValues = new Array(); + let i = 0; + while (i < w) { + const adjacentBounds = getAdjacentArrayBounds(i, spread, w); + const interpolatedColumns = getInterpolatedSequence(...adjacentBounds); + + const columnComposite = new Array(h); + for (var depth = 0; depth < h; depth++) { + columnComposite[depth] = getCompositeColumnDepthValues(columns, interpolatedColumns, depth).join('|'); + } + interpolatedColumnsValues.push(columnComposite); + i += spread; + } + return interpolatedColumnsValues; +} + +function ungroupAdjacent(grouped, spread, h, w) { + if (!spread) { + return grouped; + } + + function mapUngroupedColumnIndexToGroupedIndex(index, spread) { + return Math.floor(index / spread); + } + + const ungrouped = new Array(w); + for (let i = 0; i < w; i++) { + if (!ungrouped[i]) { + ungrouped[i] = new Array(h); + } + + const groupedIndex = mapUngroupedColumnIndexToGroupedIndex(i, spread); + for (let j = 0; j < h; j++) { + ungrouped[i][j] = grouped[groupedIndex][j].split('|')[0]; + } + } + + return ungrouped +} + + + +function imgDataWordArrToColsAndRows(arr, h, w) { + let columns = new Array(w); + let rows = new Array(h); + + for (var i = 0; i < arr.length; i++) { + const word = arr[i]; + + var {column, depth} = serialToColumnMap(i, h, w); + if (!columns[column]) { + columns[column] = new Array(h); + } + columns[column][depth] = word; + + var {row, index} = serialToRowMap(i, h, w); + if (!rows[row]) { + rows[row] = new Array(w); + } + rows[row][index] = word; + } + return {columns, rows} +} + +function serialToColumnMap(index, h, w) { + return { + column: index % w, + depth: Math.floor(index / w) + } +} + +function serialToRowMap(index, h, w) { + return { + row: Math.floor(index / w), + index: index % w + } +} + +function imgDataToWords(arr) { + let result = []; + for (let i = 0; i < arr.length-1; i += 4) { + result.push(`${arr[i]}_${arr[i+1]}_${arr[i+2]}_${arr[i+3]}`) + } + return result; +} + + +/***/ }), +/* 297 */ +/***/ (function(module, exports, __webpack_require__) { + +/*! + + diff v3.5.0 + +Software License Agreement (BSD License) + +Copyright (c) 2009-2015, Kevin Decker + +All rights reserved. + +Redistribution and use of this software in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + +* Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + +* Neither the name of Kevin Decker nor the names of its + contributors may be used to endorse or promote products + derived from this software without specific prior + written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR +IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND +FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER +IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@license +*/ +(function webpackUniversalModuleDefinition(root, factory) { + if(true) + module.exports = factory(); + else if(typeof define === 'function' && define.amd) + define([], factory); + else if(typeof exports === 'object') + exports["JsDiff"] = factory(); + else + root["JsDiff"] = factory(); +})(this, function() { +return /******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; + +/******/ // The require function +/******/ function __webpack_require__(moduleId) { + +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) +/******/ return installedModules[moduleId].exports; + +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ exports: {}, +/******/ id: moduleId, +/******/ loaded: false +/******/ }; + +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); + +/******/ // Flag the module as loaded +/******/ module.loaded = true; + +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } + + +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; + +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; + +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; + +/******/ // Load entry module and return exports +/******/ return __webpack_require__(0); +/******/ }) +/************************************************************************/ +/******/ ([ +/* 0 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.canonicalize = exports.convertChangesToXML = exports.convertChangesToDMP = exports.merge = exports.parsePatch = exports.applyPatches = exports.applyPatch = exports.createPatch = exports.createTwoFilesPatch = exports.structuredPatch = exports.diffArrays = exports.diffJson = exports.diffCss = exports.diffSentences = exports.diffTrimmedLines = exports.diffLines = exports.diffWordsWithSpace = exports.diffWords = exports.diffChars = exports.Diff = undefined; + + /*istanbul ignore end*/var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_character = __webpack_require__(2) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_word = __webpack_require__(3) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_sentence = __webpack_require__(6) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_css = __webpack_require__(7) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_json = __webpack_require__(8) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_array = __webpack_require__(9) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_apply = __webpack_require__(10) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_merge = __webpack_require__(13) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_create = __webpack_require__(14) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_dmp = __webpack_require__(16) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_xml = __webpack_require__(17) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /* See LICENSE file for terms of use */ + + /* + * Text diff implementation. + * + * This library supports the following APIS: + * JsDiff.diffChars: Character by character diff + * JsDiff.diffWords: Word (as defined by \b regex) diff which ignores whitespace + * JsDiff.diffLines: Line based diff + * + * JsDiff.diffCss: Diff targeted at CSS content + * + * These methods are based on the implementation proposed in + * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986). + * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927 + */ + exports. /*istanbul ignore end*/Diff = _base2['default']; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffChars = _character.diffChars; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWords = _word.diffWords; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = _word.diffWordsWithSpace; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffLines = _line.diffLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = _line.diffTrimmedLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffSentences = _sentence.diffSentences; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffCss = _css.diffCss; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffJson = _json.diffJson; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffArrays = _array.diffArrays; + /*istanbul ignore start*/exports. /*istanbul ignore end*/structuredPatch = _create.structuredPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = _create.createTwoFilesPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = _create.createPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatch = _apply.applyPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = _apply.applyPatches; + /*istanbul ignore start*/exports. /*istanbul ignore end*/parsePatch = _parse.parsePatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/merge = _merge.merge; + /*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToDMP = _dmp.convertChangesToDMP; + /*istanbul ignore start*/exports. /*istanbul ignore end*/convertChangesToXML = _xml.convertChangesToXML; + /*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = _json.canonicalize; + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 1 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports['default'] = /*istanbul ignore end*/Diff; + function Diff() {} + + Diff.prototype = { + /*istanbul ignore start*/ /*istanbul ignore end*/diff: function diff(oldString, newString) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + var callback = options.callback; + if (typeof options === 'function') { + callback = options; + options = {}; + } + this.options = options; + + var self = this; + + function done(value) { + if (callback) { + setTimeout(function () { + callback(undefined, value); + }, 0); + return true; + } else { + return value; + } + } + + // Allow subclasses to massage the input prior to running + oldString = this.castInput(oldString); + newString = this.castInput(newString); + + oldString = this.removeEmpty(this.tokenize(oldString)); + newString = this.removeEmpty(this.tokenize(newString)); + + var newLen = newString.length, + oldLen = oldString.length; + var editLength = 1; + var maxEditLength = newLen + oldLen; + var bestPath = [{ newPos: -1, components: [] }]; + + // Seed editLength = 0, i.e. the content starts with the same values + var oldPos = this.extractCommon(bestPath[0], newString, oldString, 0); + if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) { + // Identity per the equality and tokenizer + return done([{ value: this.join(newString), count: newString.length }]); + } + + // Main worker method. checks all permutations of a given edit length for acceptance. + function execEditLength() { + for (var diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) { + var basePath = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + var addPath = bestPath[diagonalPath - 1], + removePath = bestPath[diagonalPath + 1], + _oldPos = (removePath ? removePath.newPos : 0) - diagonalPath; + if (addPath) { + // No one else is going to attempt to use this value, clear it + bestPath[diagonalPath - 1] = undefined; + } + + var canAdd = addPath && addPath.newPos + 1 < newLen, + canRemove = removePath && 0 <= _oldPos && _oldPos < oldLen; + if (!canAdd && !canRemove) { + // If this path is a terminal then prune + bestPath[diagonalPath] = undefined; + continue; + } + + // Select the diagonal that we want to branch from. We select the prior + // path whose position in the new string is the farthest from the origin + // and does not pass the bounds of the diff graph + if (!canAdd || canRemove && addPath.newPos < removePath.newPos) { + basePath = clonePath(removePath); + self.pushComponent(basePath.components, undefined, true); + } else { + basePath = addPath; // No need to clone, we've pulled it from the list + basePath.newPos++; + self.pushComponent(basePath.components, true, undefined); + } + + _oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath); + + // If we have hit the end of both strings, then we are done + if (basePath.newPos + 1 >= newLen && _oldPos + 1 >= oldLen) { + return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken)); + } else { + // Otherwise track this path as a potential candidate and continue. + bestPath[diagonalPath] = basePath; + } + } + + editLength++; + } + + // Performs the length of edit iteration. Is a bit fugly as this has to support the + // sync and async mode which is never fun. Loops over execEditLength until a value + // is produced. + if (callback) { + (function exec() { + setTimeout(function () { + // This should not happen, but we want to be safe. + /* istanbul ignore next */ + if (editLength > maxEditLength) { + return callback(); + } + + if (!execEditLength()) { + exec(); + } + }, 0); + })(); + } else { + while (editLength <= maxEditLength) { + var ret = execEditLength(); + if (ret) { + return ret; + } + } + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/pushComponent: function pushComponent(components, added, removed) { + var last = components[components.length - 1]; + if (last && last.added === added && last.removed === removed) { + // We need to clone here as the component clone operation is just + // as shallow array clone + components[components.length - 1] = { count: last.count + 1, added: added, removed: removed }; + } else { + components.push({ count: 1, added: added, removed: removed }); + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/extractCommon: function extractCommon(basePath, newString, oldString, diagonalPath) { + var newLen = newString.length, + oldLen = oldString.length, + newPos = basePath.newPos, + oldPos = newPos - diagonalPath, + commonCount = 0; + while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) { + newPos++; + oldPos++; + commonCount++; + } + + if (commonCount) { + basePath.components.push({ count: commonCount }); + } + + basePath.newPos = newPos; + return oldPos; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/equals: function equals(left, right) { + if (this.options.comparator) { + return this.options.comparator(left, right); + } else { + return left === right || this.options.ignoreCase && left.toLowerCase() === right.toLowerCase(); + } + }, + /*istanbul ignore start*/ /*istanbul ignore end*/removeEmpty: function removeEmpty(array) { + var ret = []; + for (var i = 0; i < array.length; i++) { + if (array[i]) { + ret.push(array[i]); + } + } + return ret; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/castInput: function castInput(value) { + return value; + }, + /*istanbul ignore start*/ /*istanbul ignore end*/tokenize: function tokenize(value) { + return value.split(''); + }, + /*istanbul ignore start*/ /*istanbul ignore end*/join: function join(chars) { + return chars.join(''); + } + }; + + function buildValues(diff, components, newString, oldString, useLongestToken) { + var componentPos = 0, + componentLen = components.length, + newPos = 0, + oldPos = 0; + + for (; componentPos < componentLen; componentPos++) { + var component = components[componentPos]; + if (!component.removed) { + if (!component.added && useLongestToken) { + var value = newString.slice(newPos, newPos + component.count); + value = value.map(function (value, i) { + var oldValue = oldString[oldPos + i]; + return oldValue.length > value.length ? oldValue : value; + }); + + component.value = diff.join(value); + } else { + component.value = diff.join(newString.slice(newPos, newPos + component.count)); + } + newPos += component.count; + + // Common case + if (!component.added) { + oldPos += component.count; + } + } else { + component.value = diff.join(oldString.slice(oldPos, oldPos + component.count)); + oldPos += component.count; + + // Reverse add and remove so removes are output first to match common convention + // The diffing algorithm is tied to add then remove output and this is the simplest + // route to get the desired output with minimal overhead. + if (componentPos && components[componentPos - 1].added) { + var tmp = components[componentPos - 1]; + components[componentPos - 1] = components[componentPos]; + components[componentPos] = tmp; + } + } + } + + // Special case handle for when one terminal is ignored (i.e. whitespace). + // For this case we merge the terminal into the prior string and drop the change. + // This is only available for string mode. + var lastComponent = components[componentLen - 1]; + if (componentLen > 1 && typeof lastComponent.value === 'string' && (lastComponent.added || lastComponent.removed) && diff.equals('', lastComponent.value)) { + components[componentLen - 2].value += lastComponent.value; + components.pop(); + } + + return components; + } + + function clonePath(path) { + return { newPos: path.newPos, components: path.components.slice(0) }; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/diff/base.js"],"names":["Diff","prototype","diff","oldString","newString","options","callback","self","done","value","setTimeout","undefined","castInput","removeEmpty","tokenize","newLen","length","oldLen","editLength","maxEditLength","bestPath","newPos","components","oldPos","extractCommon","join","count","execEditLength","diagonalPath","basePath","addPath","removePath","canAdd","canRemove","clonePath","pushComponent","buildValues","useLongestToken","exec","ret","added","removed","last","push","commonCount","equals","left","right","comparator","ignoreCase","toLowerCase","array","i","split","chars","componentPos","componentLen","component","slice","map","oldValue","tmp","lastComponent","pop","path"],"mappings":"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","file":"base.js","sourcesContent":["export default function Diff() {}\n\nDiff.prototype = {\n  diff(oldString, newString, options = {}) {\n    let callback = options.callback;\n    if (typeof options === 'function') {\n      callback = options;\n      options = {};\n    }\n    this.options = options;\n\n    let self = this;\n\n    function done(value) {\n      if (callback) {\n        setTimeout(function() { callback(undefined, value); }, 0);\n        return true;\n      } else {\n        return value;\n      }\n    }\n\n    // Allow subclasses to massage the input prior to running\n    oldString = this.castInput(oldString);\n    newString = this.castInput(newString);\n\n    oldString = this.removeEmpty(this.tokenize(oldString));\n    newString = this.removeEmpty(this.tokenize(newString));\n\n    let newLen = newString.length, oldLen = oldString.length;\n    let editLength = 1;\n    let maxEditLength = newLen + oldLen;\n    let bestPath = [{ newPos: -1, components: [] }];\n\n    // Seed editLength = 0, i.e. the content starts with the same values\n    let oldPos = this.extractCommon(bestPath[0], newString, oldString, 0);\n    if (bestPath[0].newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n      // Identity per the equality and tokenizer\n      return done([{value: this.join(newString), count: newString.length}]);\n    }\n\n    // Main worker method. checks all permutations of a given edit length for acceptance.\n    function execEditLength() {\n      for (let diagonalPath = -1 * editLength; diagonalPath <= editLength; diagonalPath += 2) {\n        let basePath;\n        let addPath = bestPath[diagonalPath - 1],\n            removePath = bestPath[diagonalPath + 1],\n            oldPos = (removePath ? removePath.newPos : 0) - diagonalPath;\n        if (addPath) {\n          // No one else is going to attempt to use this value, clear it\n          bestPath[diagonalPath - 1] = undefined;\n        }\n\n        let canAdd = addPath && addPath.newPos + 1 < newLen,\n            canRemove = removePath && 0 <= oldPos && oldPos < oldLen;\n        if (!canAdd && !canRemove) {\n          // If this path is a terminal then prune\n          bestPath[diagonalPath] = undefined;\n          continue;\n        }\n\n        // Select the diagonal that we want to branch from. We select the prior\n        // path whose position in the new string is the farthest from the origin\n        // and does not pass the bounds of the diff graph\n        if (!canAdd || (canRemove && addPath.newPos < removePath.newPos)) {\n          basePath = clonePath(removePath);\n          self.pushComponent(basePath.components, undefined, true);\n        } else {\n          basePath = addPath;   // No need to clone, we've pulled it from the list\n          basePath.newPos++;\n          self.pushComponent(basePath.components, true, undefined);\n        }\n\n        oldPos = self.extractCommon(basePath, newString, oldString, diagonalPath);\n\n        // If we have hit the end of both strings, then we are done\n        if (basePath.newPos + 1 >= newLen && oldPos + 1 >= oldLen) {\n          return done(buildValues(self, basePath.components, newString, oldString, self.useLongestToken));\n        } else {\n          // Otherwise track this path as a potential candidate and continue.\n          bestPath[diagonalPath] = basePath;\n        }\n      }\n\n      editLength++;\n    }\n\n    // Performs the length of edit iteration. Is a bit fugly as this has to support the\n    // sync and async mode which is never fun. Loops over execEditLength until a value\n    // is produced.\n    if (callback) {\n      (function exec() {\n        setTimeout(function() {\n          // This should not happen, but we want to be safe.\n          /* istanbul ignore next */\n          if (editLength > maxEditLength) {\n            return callback();\n          }\n\n          if (!execEditLength()) {\n            exec();\n          }\n        }, 0);\n      }());\n    } else {\n      while (editLength <= maxEditLength) {\n        let ret = execEditLength();\n        if (ret) {\n          return ret;\n        }\n      }\n    }\n  },\n\n  pushComponent(components, added, removed) {\n    let last = components[components.length - 1];\n    if (last && last.added === added && last.removed === removed) {\n      // We need to clone here as the component clone operation is just\n      // as shallow array clone\n      components[components.length - 1] = {count: last.count + 1, added: added, removed: removed };\n    } else {\n      components.push({count: 1, added: added, removed: removed });\n    }\n  },\n  extractCommon(basePath, newString, oldString, diagonalPath) {\n    let newLen = newString.length,\n        oldLen = oldString.length,\n        newPos = basePath.newPos,\n        oldPos = newPos - diagonalPath,\n\n        commonCount = 0;\n    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(newString[newPos + 1], oldString[oldPos + 1])) {\n      newPos++;\n      oldPos++;\n      commonCount++;\n    }\n\n    if (commonCount) {\n      basePath.components.push({count: commonCount});\n    }\n\n    basePath.newPos = newPos;\n    return oldPos;\n  },\n\n  equals(left, right) {\n    if (this.options.comparator) {\n      return this.options.comparator(left, right);\n    } else {\n      return left === right\n        || (this.options.ignoreCase && left.toLowerCase() === right.toLowerCase());\n    }\n  },\n  removeEmpty(array) {\n    let ret = [];\n    for (let i = 0; i < array.length; i++) {\n      if (array[i]) {\n        ret.push(array[i]);\n      }\n    }\n    return ret;\n  },\n  castInput(value) {\n    return value;\n  },\n  tokenize(value) {\n    return value.split('');\n  },\n  join(chars) {\n    return chars.join('');\n  }\n};\n\nfunction buildValues(diff, components, newString, oldString, useLongestToken) {\n  let componentPos = 0,\n      componentLen = components.length,\n      newPos = 0,\n      oldPos = 0;\n\n  for (; componentPos < componentLen; componentPos++) {\n    let component = components[componentPos];\n    if (!component.removed) {\n      if (!component.added && useLongestToken) {\n        let value = newString.slice(newPos, newPos + component.count);\n        value = value.map(function(value, i) {\n          let oldValue = oldString[oldPos + i];\n          return oldValue.length > value.length ? oldValue : value;\n        });\n\n        component.value = diff.join(value);\n      } else {\n        component.value = diff.join(newString.slice(newPos, newPos + component.count));\n      }\n      newPos += component.count;\n\n      // Common case\n      if (!component.added) {\n        oldPos += component.count;\n      }\n    } else {\n      component.value = diff.join(oldString.slice(oldPos, oldPos + component.count));\n      oldPos += component.count;\n\n      // Reverse add and remove so removes are output first to match common convention\n      // The diffing algorithm is tied to add then remove output and this is the simplest\n      // route to get the desired output with minimal overhead.\n      if (componentPos && components[componentPos - 1].added) {\n        let tmp = components[componentPos - 1];\n        components[componentPos - 1] = components[componentPos];\n        components[componentPos] = tmp;\n      }\n    }\n  }\n\n  // Special case handle for when one terminal is ignored (i.e. whitespace).\n  // For this case we merge the terminal into the prior string and drop the change.\n  // This is only available for string mode.\n  let lastComponent = components[componentLen - 1];\n  if (componentLen > 1\n      && typeof lastComponent.value === 'string'\n      && (lastComponent.added || lastComponent.removed)\n      && diff.equals('', lastComponent.value)) {\n    components[componentLen - 2].value += lastComponent.value;\n    components.pop();\n  }\n\n  return components;\n}\n\nfunction clonePath(path) {\n  return { newPos: path.newPos, components: path.components.slice(0) };\n}\n"]} + + +/***/ }), +/* 2 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.characterDiff = undefined; + exports. /*istanbul ignore end*/diffChars = diffChars; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var characterDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/characterDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + function diffChars(oldStr, newStr, options) { + return characterDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2NoYXJhY3Rlci5qcyJdLCJuYW1lcyI6WyJkaWZmQ2hhcnMiLCJjaGFyYWN0ZXJEaWZmIiwib2xkU3RyIiwibmV3U3RyIiwib3B0aW9ucyIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBR2dCQSxTLEdBQUFBLFM7O0FBSGhCOzs7Ozs7dUJBRU8sSUFBTUMseUZBQWdCLHdFQUF0QjtBQUNBLFNBQVNELFNBQVQsQ0FBbUJFLE1BQW5CLEVBQTJCQyxNQUEzQixFQUFtQ0MsT0FBbkMsRUFBNEM7QUFBRSxTQUFPSCxjQUFjSSxJQUFkLENBQW1CSCxNQUFuQixFQUEyQkMsTUFBM0IsRUFBbUNDLE9BQW5DLENBQVA7QUFBcUQiLCJmaWxlIjoiY2hhcmFjdGVyLmpzIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IERpZmYgZnJvbSAnLi9iYXNlJztcblxuZXhwb3J0IGNvbnN0IGNoYXJhY3RlckRpZmYgPSBuZXcgRGlmZigpO1xuZXhwb3J0IGZ1bmN0aW9uIGRpZmZDaGFycyhvbGRTdHIsIG5ld1N0ciwgb3B0aW9ucykgeyByZXR1cm4gY2hhcmFjdGVyRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBvcHRpb25zKTsgfVxuIl19 + + +/***/ }), +/* 3 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.wordDiff = undefined; + exports. /*istanbul ignore end*/diffWords = diffWords; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffWordsWithSpace = diffWordsWithSpace; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_params = __webpack_require__(4) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/ // Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode + // + // Ranges and exceptions: + // Latin-1 Supplement, 0080–00FF + // - U+00D7 × Multiplication sign + // - U+00F7 ÷ Division sign + // Latin Extended-A, 0100–017F + // Latin Extended-B, 0180–024F + // IPA Extensions, 0250–02AF + // Spacing Modifier Letters, 02B0–02FF + // - U+02C7 ˇ ˇ Caron + // - U+02D8 ˘ ˘ Breve + // - U+02D9 ˙ ˙ Dot Above + // - U+02DA ˚ ˚ Ring Above + // - U+02DB ˛ ˛ Ogonek + // - U+02DC ˜ ˜ Small Tilde + // - U+02DD ˝ ˝ Double Acute Accent + // Latin Extended Additional, 1E00–1EFF + var extendedWordChars = /^[A-Za-z\xC0-\u02C6\u02C8-\u02D7\u02DE-\u02FF\u1E00-\u1EFF]+$/; + + var reWhitespace = /\S/; + + var wordDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/wordDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + wordDiff.equals = function (left, right) { + if (this.options.ignoreCase) { + left = left.toLowerCase(); + right = right.toLowerCase(); + } + return left === right || this.options.ignoreWhitespace && !reWhitespace.test(left) && !reWhitespace.test(right); + }; + wordDiff.tokenize = function (value) { + var tokens = value.split(/(\s+|\b)/); + + // Join the boundary splits that we do not consider to be boundaries. This is primarily the extended Latin character set. + for (var i = 0; i < tokens.length - 1; i++) { + // If we have an empty string in the next field and we have only word chars before and after, merge + if (!tokens[i + 1] && tokens[i + 2] && extendedWordChars.test(tokens[i]) && extendedWordChars.test(tokens[i + 2])) { + tokens[i] += tokens[i + 2]; + tokens.splice(i + 1, 2); + i--; + } + } + + return tokens; + }; + + function diffWords(oldStr, newStr, options) { + options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(options, { ignoreWhitespace: true }); + return wordDiff.diff(oldStr, newStr, options); + } + + function diffWordsWithSpace(oldStr, newStr, options) { + return wordDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 4 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/generateOptions = generateOptions; + function generateOptions(options, defaults) { + if (typeof options === 'function') { + defaults.callback = options; + } else if (options) { + for (var name in options) { + /* istanbul ignore else */ + if (options.hasOwnProperty(name)) { + defaults[name] = options[name]; + } + } + } + return defaults; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL3BhcmFtcy5qcyJdLCJuYW1lcyI6WyJnZW5lcmF0ZU9wdGlvbnMiLCJvcHRpb25zIiwiZGVmYXVsdHMiLCJjYWxsYmFjayIsIm5hbWUiLCJoYXNPd25Qcm9wZXJ0eSJdLCJtYXBwaW5ncyI6Ijs7O2dDQUFnQkEsZSxHQUFBQSxlO0FBQVQsU0FBU0EsZUFBVCxDQUF5QkMsT0FBekIsRUFBa0NDLFFBQWxDLEVBQTRDO0FBQ2pELE1BQUksT0FBT0QsT0FBUCxLQUFtQixVQUF2QixFQUFtQztBQUNqQ0MsYUFBU0MsUUFBVCxHQUFvQkYsT0FBcEI7QUFDRCxHQUZELE1BRU8sSUFBSUEsT0FBSixFQUFhO0FBQ2xCLFNBQUssSUFBSUcsSUFBVCxJQUFpQkgsT0FBakIsRUFBMEI7QUFDeEI7QUFDQSxVQUFJQSxRQUFRSSxjQUFSLENBQXVCRCxJQUF2QixDQUFKLEVBQWtDO0FBQ2hDRixpQkFBU0UsSUFBVCxJQUFpQkgsUUFBUUcsSUFBUixDQUFqQjtBQUNEO0FBQ0Y7QUFDRjtBQUNELFNBQU9GLFFBQVA7QUFDRCIsImZpbGUiOiJwYXJhbXMuanMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gZ2VuZXJhdGVPcHRpb25zKG9wdGlvbnMsIGRlZmF1bHRzKSB7XG4gIGlmICh0eXBlb2Ygb3B0aW9ucyA9PT0gJ2Z1bmN0aW9uJykge1xuICAgIGRlZmF1bHRzLmNhbGxiYWNrID0gb3B0aW9ucztcbiAgfSBlbHNlIGlmIChvcHRpb25zKSB7XG4gICAgZm9yIChsZXQgbmFtZSBpbiBvcHRpb25zKSB7XG4gICAgICAvKiBpc3RhbmJ1bCBpZ25vcmUgZWxzZSAqL1xuICAgICAgaWYgKG9wdGlvbnMuaGFzT3duUHJvcGVydHkobmFtZSkpIHtcbiAgICAgICAgZGVmYXVsdHNbbmFtZV0gPSBvcHRpb25zW25hbWVdO1xuICAgICAgfVxuICAgIH1cbiAgfVxuICByZXR1cm4gZGVmYXVsdHM7XG59XG4iXX0= + + +/***/ }), +/* 5 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.lineDiff = undefined; + exports. /*istanbul ignore end*/diffLines = diffLines; + /*istanbul ignore start*/exports. /*istanbul ignore end*/diffTrimmedLines = diffTrimmedLines; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_params = __webpack_require__(4) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var lineDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/lineDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + lineDiff.tokenize = function (value) { + var retLines = [], + linesAndNewlines = value.split(/(\n|\r\n)/); + + // Ignore the final empty token that occurs if the string ends with a new line + if (!linesAndNewlines[linesAndNewlines.length - 1]) { + linesAndNewlines.pop(); + } + + // Merge the content and line separators into single tokens + for (var i = 0; i < linesAndNewlines.length; i++) { + var line = linesAndNewlines[i]; + + if (i % 2 && !this.options.newlineIsToken) { + retLines[retLines.length - 1] += line; + } else { + if (this.options.ignoreWhitespace) { + line = line.trim(); + } + retLines.push(line); + } + } + + return retLines; + }; + + function diffLines(oldStr, newStr, callback) { + return lineDiff.diff(oldStr, newStr, callback); + } + function diffTrimmedLines(oldStr, newStr, callback) { + var options = /*istanbul ignore start*/(0, _params.generateOptions) /*istanbul ignore end*/(callback, { ignoreWhitespace: true }); + return lineDiff.diff(oldStr, newStr, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 6 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.sentenceDiff = undefined; + exports. /*istanbul ignore end*/diffSentences = diffSentences; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var sentenceDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/sentenceDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + sentenceDiff.tokenize = function (value) { + return value.split(/(\S.+?[.!?])(?=\s+|$)/); + }; + + function diffSentences(oldStr, newStr, callback) { + return sentenceDiff.diff(oldStr, newStr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL3NlbnRlbmNlLmpzIl0sIm5hbWVzIjpbImRpZmZTZW50ZW5jZXMiLCJzZW50ZW5jZURpZmYiLCJ0b2tlbml6ZSIsInZhbHVlIiwic3BsaXQiLCJvbGRTdHIiLCJuZXdTdHIiLCJjYWxsYmFjayIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBUWdCQSxhLEdBQUFBLGE7O0FBUmhCOzs7Ozs7dUJBR08sSUFBTUMsdUZBQWUsd0VBQXJCO0FBQ1BBLGFBQWFDLFFBQWIsR0FBd0IsVUFBU0MsS0FBVCxFQUFnQjtBQUN0QyxTQUFPQSxNQUFNQyxLQUFOLENBQVksdUJBQVosQ0FBUDtBQUNELENBRkQ7O0FBSU8sU0FBU0osYUFBVCxDQUF1QkssTUFBdkIsRUFBK0JDLE1BQS9CLEVBQXVDQyxRQUF2QyxFQUFpRDtBQUFFLFNBQU9OLGFBQWFPLElBQWIsQ0FBa0JILE1BQWxCLEVBQTBCQyxNQUExQixFQUFrQ0MsUUFBbEMsQ0FBUDtBQUFxRCIsImZpbGUiOiJzZW50ZW5jZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cblxuZXhwb3J0IGNvbnN0IHNlbnRlbmNlRGlmZiA9IG5ldyBEaWZmKCk7XG5zZW50ZW5jZURpZmYudG9rZW5pemUgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWUuc3BsaXQoLyhcXFMuKz9bLiE/XSkoPz1cXHMrfCQpLyk7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZlNlbnRlbmNlcyhvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spIHsgcmV0dXJuIHNlbnRlbmNlRGlmZi5kaWZmKG9sZFN0ciwgbmV3U3RyLCBjYWxsYmFjayk7IH1cbiJdfQ== + + +/***/ }), +/* 7 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.cssDiff = undefined; + exports. /*istanbul ignore end*/diffCss = diffCss; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var cssDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/cssDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + cssDiff.tokenize = function (value) { + return value.split(/([{}:;,]|\s+)/); + }; + + function diffCss(oldStr, newStr, callback) { + return cssDiff.diff(oldStr, newStr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2Nzcy5qcyJdLCJuYW1lcyI6WyJkaWZmQ3NzIiwiY3NzRGlmZiIsInRva2VuaXplIiwidmFsdWUiLCJzcGxpdCIsIm9sZFN0ciIsIm5ld1N0ciIsImNhbGxiYWNrIiwiZGlmZiJdLCJtYXBwaW5ncyI6Ijs7OztnQ0FPZ0JBLE8sR0FBQUEsTzs7QUFQaEI7Ozs7Ozt1QkFFTyxJQUFNQyw2RUFBVSx3RUFBaEI7QUFDUEEsUUFBUUMsUUFBUixHQUFtQixVQUFTQyxLQUFULEVBQWdCO0FBQ2pDLFNBQU9BLE1BQU1DLEtBQU4sQ0FBWSxlQUFaLENBQVA7QUFDRCxDQUZEOztBQUlPLFNBQVNKLE9BQVQsQ0FBaUJLLE1BQWpCLEVBQXlCQyxNQUF6QixFQUFpQ0MsUUFBakMsRUFBMkM7QUFBRSxTQUFPTixRQUFRTyxJQUFSLENBQWFILE1BQWIsRUFBcUJDLE1BQXJCLEVBQTZCQyxRQUE3QixDQUFQO0FBQWdEIiwiZmlsZSI6ImNzcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cbmV4cG9ydCBjb25zdCBjc3NEaWZmID0gbmV3IERpZmYoKTtcbmNzc0RpZmYudG9rZW5pemUgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWUuc3BsaXQoLyhbe306OyxdfFxccyspLyk7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZkNzcyhvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spIHsgcmV0dXJuIGNzc0RpZmYuZGlmZihvbGRTdHIsIG5ld1N0ciwgY2FsbGJhY2spOyB9XG4iXX0= + + +/***/ }), +/* 8 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.jsonDiff = undefined; + + var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; + + exports. /*istanbul ignore end*/diffJson = diffJson; + /*istanbul ignore start*/exports. /*istanbul ignore end*/canonicalize = canonicalize; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + /*istanbul ignore end*/var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var objectPrototypeToString = Object.prototype.toString; + + var jsonDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/jsonDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a + // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output: + jsonDiff.useLongestToken = true; + + jsonDiff.tokenize = /*istanbul ignore start*/_line.lineDiff /*istanbul ignore end*/.tokenize; + jsonDiff.castInput = function (value) { + /*istanbul ignore start*/var _options = /*istanbul ignore end*/this.options, + undefinedReplacement = _options.undefinedReplacement, + _options$stringifyRep = _options.stringifyReplacer, + stringifyReplacer = _options$stringifyRep === undefined ? function (k, v) /*istanbul ignore start*/{ + return (/*istanbul ignore end*/typeof v === 'undefined' ? undefinedReplacement : v + ); + } : _options$stringifyRep; + + + return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, ' '); + }; + jsonDiff.equals = function (left, right) { + return (/*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1')) + ); + }; + + function diffJson(oldObj, newObj, options) { + return jsonDiff.diff(oldObj, newObj, options); + } + + // This function handles the presence of circular references by bailing out when encountering an + // object that is already on the "stack" of items being processed. Accepts an optional replacer + function canonicalize(obj, stack, replacementStack, replacer, key) { + stack = stack || []; + replacementStack = replacementStack || []; + + if (replacer) { + obj = replacer(key, obj); + } + + var i = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + for (i = 0; i < stack.length; i += 1) { + if (stack[i] === obj) { + return replacementStack[i]; + } + } + + var canonicalizedObj = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + if ('[object Array]' === objectPrototypeToString.call(obj)) { + stack.push(obj); + canonicalizedObj = new Array(obj.length); + replacementStack.push(canonicalizedObj); + for (i = 0; i < obj.length; i += 1) { + canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, key); + } + stack.pop(); + replacementStack.pop(); + return canonicalizedObj; + } + + if (obj && obj.toJSON) { + obj = obj.toJSON(); + } + + if ( /*istanbul ignore start*/(typeof /*istanbul ignore end*/obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && obj !== null) { + stack.push(obj); + canonicalizedObj = {}; + replacementStack.push(canonicalizedObj); + var sortedKeys = [], + _key = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + for (_key in obj) { + /* istanbul ignore else */ + if (obj.hasOwnProperty(_key)) { + sortedKeys.push(_key); + } + } + sortedKeys.sort(); + for (i = 0; i < sortedKeys.length; i += 1) { + _key = sortedKeys[i]; + canonicalizedObj[_key] = canonicalize(obj[_key], stack, replacementStack, replacer, _key); + } + stack.pop(); + replacementStack.pop(); + } else { + canonicalizedObj = obj; + } + return canonicalizedObj; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,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 + + +/***/ }), +/* 9 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports.arrayDiff = undefined; + exports. /*istanbul ignore end*/diffArrays = diffArrays; + + var /*istanbul ignore start*/_base = __webpack_require__(1) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _base2 = _interopRequireDefault(_base); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/var arrayDiff = /*istanbul ignore start*/exports. /*istanbul ignore end*/arrayDiff = new /*istanbul ignore start*/_base2['default'] /*istanbul ignore end*/(); + arrayDiff.tokenize = function (value) { + return value.slice(); + }; + arrayDiff.join = arrayDiff.removeEmpty = function (value) { + return value; + }; + + function diffArrays(oldArr, newArr, callback) { + return arrayDiff.diff(oldArr, newArr, callback); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9kaWZmL2FycmF5LmpzIl0sIm5hbWVzIjpbImRpZmZBcnJheXMiLCJhcnJheURpZmYiLCJ0b2tlbml6ZSIsInZhbHVlIiwic2xpY2UiLCJqb2luIiwicmVtb3ZlRW1wdHkiLCJvbGRBcnIiLCJuZXdBcnIiLCJjYWxsYmFjayIsImRpZmYiXSwibWFwcGluZ3MiOiI7Ozs7Z0NBVWdCQSxVLEdBQUFBLFU7O0FBVmhCOzs7Ozs7dUJBRU8sSUFBTUMsaUZBQVksd0VBQWxCO0FBQ1BBLFVBQVVDLFFBQVYsR0FBcUIsVUFBU0MsS0FBVCxFQUFnQjtBQUNuQyxTQUFPQSxNQUFNQyxLQUFOLEVBQVA7QUFDRCxDQUZEO0FBR0FILFVBQVVJLElBQVYsR0FBaUJKLFVBQVVLLFdBQVYsR0FBd0IsVUFBU0gsS0FBVCxFQUFnQjtBQUN2RCxTQUFPQSxLQUFQO0FBQ0QsQ0FGRDs7QUFJTyxTQUFTSCxVQUFULENBQW9CTyxNQUFwQixFQUE0QkMsTUFBNUIsRUFBb0NDLFFBQXBDLEVBQThDO0FBQUUsU0FBT1IsVUFBVVMsSUFBVixDQUFlSCxNQUFmLEVBQXVCQyxNQUF2QixFQUErQkMsUUFBL0IsQ0FBUDtBQUFrRCIsImZpbGUiOiJhcnJheS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBEaWZmIGZyb20gJy4vYmFzZSc7XG5cbmV4cG9ydCBjb25zdCBhcnJheURpZmYgPSBuZXcgRGlmZigpO1xuYXJyYXlEaWZmLnRva2VuaXplID0gZnVuY3Rpb24odmFsdWUpIHtcbiAgcmV0dXJuIHZhbHVlLnNsaWNlKCk7XG59O1xuYXJyYXlEaWZmLmpvaW4gPSBhcnJheURpZmYucmVtb3ZlRW1wdHkgPSBmdW5jdGlvbih2YWx1ZSkge1xuICByZXR1cm4gdmFsdWU7XG59O1xuXG5leHBvcnQgZnVuY3Rpb24gZGlmZkFycmF5cyhvbGRBcnIsIG5ld0FyciwgY2FsbGJhY2spIHsgcmV0dXJuIGFycmF5RGlmZi5kaWZmKG9sZEFyciwgbmV3QXJyLCBjYWxsYmFjayk7IH1cbiJdfQ== + + +/***/ }), +/* 10 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/applyPatch = applyPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/applyPatches = applyPatches; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_distanceIterator = __webpack_require__(12) /*istanbul ignore end*/; + + /*istanbul ignore start*/var _distanceIterator2 = _interopRequireDefault(_distanceIterator); + + function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; } + + /*istanbul ignore end*/function applyPatch(source, uniDiff) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + + if (typeof uniDiff === 'string') { + uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff); + } + + if (Array.isArray(uniDiff)) { + if (uniDiff.length > 1) { + throw new Error('applyPatch only works with a single input.'); + } + + uniDiff = uniDiff[0]; + } + + // Apply the diff to the input + var lines = source.split(/\r\n|[\n\v\f\r\x85]/), + delimiters = source.match(/\r\n|[\n\v\f\r\x85]/g) || [], + hunks = uniDiff.hunks, + compareLine = options.compareLine || function (lineNumber, line, operation, patchContent) /*istanbul ignore start*/{ + return (/*istanbul ignore end*/line === patchContent + ); + }, + errorCount = 0, + fuzzFactor = options.fuzzFactor || 0, + minLine = 0, + offset = 0, + removeEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/, + addEOFNL = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + + /** + * Checks if the hunk exactly fits on the provided location + */ + function hunkFits(hunk, toPos) { + for (var j = 0; j < hunk.lines.length; j++) { + var line = hunk.lines[j], + operation = line.length > 0 ? line[0] : ' ', + content = line.length > 0 ? line.substr(1) : line; + + if (operation === ' ' || operation === '-') { + // Context sanity check + if (!compareLine(toPos + 1, lines[toPos], operation, content)) { + errorCount++; + + if (errorCount > fuzzFactor) { + return false; + } + } + toPos++; + } + } + + return true; + } + + // Search best fit offsets for each hunk based on the previous ones + for (var i = 0; i < hunks.length; i++) { + var hunk = hunks[i], + maxLine = lines.length - hunk.oldLines, + localOffset = 0, + toPos = offset + hunk.oldStart - 1; + + var iterator = /*istanbul ignore start*/(0, _distanceIterator2['default']) /*istanbul ignore end*/(toPos, minLine, maxLine); + + for (; localOffset !== undefined; localOffset = iterator()) { + if (hunkFits(hunk, toPos + localOffset)) { + hunk.offset = offset += localOffset; + break; + } + } + + if (localOffset === undefined) { + return false; + } + + // Set lower text limit to end of the current hunk, so next ones don't try + // to fit over already patched text + minLine = hunk.offset + hunk.oldStart + hunk.oldLines; + } + + // Apply patch hunks + var diffOffset = 0; + for (var _i = 0; _i < hunks.length; _i++) { + var _hunk = hunks[_i], + _toPos = _hunk.oldStart + _hunk.offset + diffOffset - 1; + diffOffset += _hunk.newLines - _hunk.oldLines; + + if (_toPos < 0) { + // Creating a new file + _toPos = 0; + } + + for (var j = 0; j < _hunk.lines.length; j++) { + var line = _hunk.lines[j], + operation = line.length > 0 ? line[0] : ' ', + content = line.length > 0 ? line.substr(1) : line, + delimiter = _hunk.linedelimiters[j]; + + if (operation === ' ') { + _toPos++; + } else if (operation === '-') { + lines.splice(_toPos, 1); + delimiters.splice(_toPos, 1); + /* istanbul ignore else */ + } else if (operation === '+') { + lines.splice(_toPos, 0, content); + delimiters.splice(_toPos, 0, delimiter); + _toPos++; + } else if (operation === '\\') { + var previousOperation = _hunk.lines[j - 1] ? _hunk.lines[j - 1][0] : null; + if (previousOperation === '+') { + removeEOFNL = true; + } else if (previousOperation === '-') { + addEOFNL = true; + } + } + } + } + + // Handle EOFNL insertion/removal + if (removeEOFNL) { + while (!lines[lines.length - 1]) { + lines.pop(); + delimiters.pop(); + } + } else if (addEOFNL) { + lines.push(''); + delimiters.push('\n'); + } + for (var _k = 0; _k < lines.length - 1; _k++) { + lines[_k] = lines[_k] + delimiters[_k]; + } + return lines.join(''); + } + + // Wrapper that supports multiple file patches via callbacks. + function applyPatches(uniDiff, options) { + if (typeof uniDiff === 'string') { + uniDiff = /*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(uniDiff); + } + + var currentIndex = 0; + function processIndex() { + var index = uniDiff[currentIndex++]; + if (!index) { + return options.complete(); + } + + options.loadFile(index, function (err, data) { + if (err) { + return options.complete(err); + } + + var updatedContent = applyPatch(data, index, options); + options.patched(index, updatedContent, function (err) { + if (err) { + return options.complete(err); + } + + processIndex(); + }); + }); + } + processIndex(); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/apply.js"],"names":["applyPatch","applyPatches","source","uniDiff","options","Array","isArray","length","Error","lines","split","delimiters","match","hunks","compareLine","lineNumber","line","operation","patchContent","errorCount","fuzzFactor","minLine","offset","removeEOFNL","addEOFNL","hunkFits","hunk","toPos","j","content","substr","i","maxLine","oldLines","localOffset","oldStart","iterator","undefined","diffOffset","newLines","delimiter","linedelimiters","splice","previousOperation","pop","push","_k","join","currentIndex","processIndex","index","complete","loadFile","err","data","updatedContent","patched"],"mappings":"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","file":"apply.js","sourcesContent":["import {parsePatch} from './parse';\nimport distanceIterator from '../util/distance-iterator';\n\nexport function applyPatch(source, uniDiff, options = {}) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  if (Array.isArray(uniDiff)) {\n    if (uniDiff.length > 1) {\n      throw new Error('applyPatch only works with a single input.');\n    }\n\n    uniDiff = uniDiff[0];\n  }\n\n  // Apply the diff to the input\n  let lines = source.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = source.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      hunks = uniDiff.hunks,\n\n      compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent),\n      errorCount = 0,\n      fuzzFactor = options.fuzzFactor || 0,\n      minLine = 0,\n      offset = 0,\n\n      removeEOFNL,\n      addEOFNL;\n\n  /**\n   * Checks if the hunk exactly fits on the provided location\n   */\n  function hunkFits(hunk, toPos) {\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line);\n\n      if (operation === ' ' || operation === '-') {\n        // Context sanity check\n        if (!compareLine(toPos + 1, lines[toPos], operation, content)) {\n          errorCount++;\n\n          if (errorCount > fuzzFactor) {\n            return false;\n          }\n        }\n        toPos++;\n      }\n    }\n\n    return true;\n  }\n\n  // Search best fit offsets for each hunk based on the previous ones\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        maxLine = lines.length - hunk.oldLines,\n        localOffset = 0,\n        toPos = offset + hunk.oldStart - 1;\n\n    let iterator = distanceIterator(toPos, minLine, maxLine);\n\n    for (; localOffset !== undefined; localOffset = iterator()) {\n      if (hunkFits(hunk, toPos + localOffset)) {\n        hunk.offset = offset += localOffset;\n        break;\n      }\n    }\n\n    if (localOffset === undefined) {\n      return false;\n    }\n\n    // Set lower text limit to end of the current hunk, so next ones don't try\n    // to fit over already patched text\n    minLine = hunk.offset + hunk.oldStart + hunk.oldLines;\n  }\n\n  // Apply patch hunks\n  let diffOffset = 0;\n  for (let i = 0; i < hunks.length; i++) {\n    let hunk = hunks[i],\n        toPos = hunk.oldStart + hunk.offset + diffOffset - 1;\n    diffOffset += hunk.newLines - hunk.oldLines;\n\n    if (toPos < 0) { // Creating a new file\n      toPos = 0;\n    }\n\n    for (let j = 0; j < hunk.lines.length; j++) {\n      let line = hunk.lines[j],\n          operation = (line.length > 0 ? line[0] : ' '),\n          content = (line.length > 0 ? line.substr(1) : line),\n          delimiter = hunk.linedelimiters[j];\n\n      if (operation === ' ') {\n        toPos++;\n      } else if (operation === '-') {\n        lines.splice(toPos, 1);\n        delimiters.splice(toPos, 1);\n      /* istanbul ignore else */\n      } else if (operation === '+') {\n        lines.splice(toPos, 0, content);\n        delimiters.splice(toPos, 0, delimiter);\n        toPos++;\n      } else if (operation === '\\\\') {\n        let previousOperation = hunk.lines[j - 1] ? hunk.lines[j - 1][0] : null;\n        if (previousOperation === '+') {\n          removeEOFNL = true;\n        } else if (previousOperation === '-') {\n          addEOFNL = true;\n        }\n      }\n    }\n  }\n\n  // Handle EOFNL insertion/removal\n  if (removeEOFNL) {\n    while (!lines[lines.length - 1]) {\n      lines.pop();\n      delimiters.pop();\n    }\n  } else if (addEOFNL) {\n    lines.push('');\n    delimiters.push('\\n');\n  }\n  for (let _k = 0; _k < lines.length - 1; _k++) {\n    lines[_k] = lines[_k] + delimiters[_k];\n  }\n  return lines.join('');\n}\n\n// Wrapper that supports multiple file patches via callbacks.\nexport function applyPatches(uniDiff, options) {\n  if (typeof uniDiff === 'string') {\n    uniDiff = parsePatch(uniDiff);\n  }\n\n  let currentIndex = 0;\n  function processIndex() {\n    let index = uniDiff[currentIndex++];\n    if (!index) {\n      return options.complete();\n    }\n\n    options.loadFile(index, function(err, data) {\n      if (err) {\n        return options.complete(err);\n      }\n\n      let updatedContent = applyPatch(data, index, options);\n      options.patched(index, updatedContent, function(err) {\n        if (err) {\n          return options.complete(err);\n        }\n\n        processIndex();\n      });\n    });\n  }\n  processIndex();\n}\n"]} + + +/***/ }), +/* 11 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/parsePatch = parsePatch; + function parsePatch(uniDiff) { + /*istanbul ignore start*/var /*istanbul ignore end*/options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + + var diffstr = uniDiff.split(/\r\n|[\n\v\f\r\x85]/), + delimiters = uniDiff.match(/\r\n|[\n\v\f\r\x85]/g) || [], + list = [], + i = 0; + + function parseIndex() { + var index = {}; + list.push(index); + + // Parse diff metadata + while (i < diffstr.length) { + var line = diffstr[i]; + + // File header found, end parsing diff metadata + if (/^(\-\-\-|\+\+\+|@@)\s/.test(line)) { + break; + } + + // Diff index + var header = /^(?:Index:|diff(?: -r \w+)+)\s+(.+?)\s*$/.exec(line); + if (header) { + index.index = header[1]; + } + + i++; + } + + // Parse file headers if they are defined. Unified diff requires them, but + // there's no technical issues to have an isolated hunk without file header + parseFileHeader(index); + parseFileHeader(index); + + // Parse hunks + index.hunks = []; + + while (i < diffstr.length) { + var _line = diffstr[i]; + + if (/^(Index:|diff|\-\-\-|\+\+\+)\s/.test(_line)) { + break; + } else if (/^@@/.test(_line)) { + index.hunks.push(parseHunk()); + } else if (_line && options.strict) { + // Ignore unexpected content unless in strict mode + throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(_line)); + } else { + i++; + } + } + } + + // Parses the --- and +++ headers, if none are found, no lines + // are consumed. + function parseFileHeader(index) { + var fileHeader = /^(---|\+\+\+)\s+(.*)$/.exec(diffstr[i]); + if (fileHeader) { + var keyPrefix = fileHeader[1] === '---' ? 'old' : 'new'; + var data = fileHeader[2].split('\t', 2); + var fileName = data[0].replace(/\\\\/g, '\\'); + if (/^".*"$/.test(fileName)) { + fileName = fileName.substr(1, fileName.length - 2); + } + index[keyPrefix + 'FileName'] = fileName; + index[keyPrefix + 'Header'] = (data[1] || '').trim(); + + i++; + } + } + + // Parses a hunk + // This assumes that we are at the start of a hunk. + function parseHunk() { + var chunkHeaderIndex = i, + chunkHeaderLine = diffstr[i++], + chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/); + + var hunk = { + oldStart: +chunkHeader[1], + oldLines: +chunkHeader[2] || 1, + newStart: +chunkHeader[3], + newLines: +chunkHeader[4] || 1, + lines: [], + linedelimiters: [] + }; + + var addCount = 0, + removeCount = 0; + for (; i < diffstr.length; i++) { + // Lines starting with '---' could be mistaken for the "remove line" operation + // But they could be the header for the next file. Therefore prune such cases out. + if (diffstr[i].indexOf('--- ') === 0 && i + 2 < diffstr.length && diffstr[i + 1].indexOf('+++ ') === 0 && diffstr[i + 2].indexOf('@@') === 0) { + break; + } + var operation = diffstr[i].length == 0 && i != diffstr.length - 1 ? ' ' : diffstr[i][0]; + + if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') { + hunk.lines.push(diffstr[i]); + hunk.linedelimiters.push(delimiters[i] || '\n'); + + if (operation === '+') { + addCount++; + } else if (operation === '-') { + removeCount++; + } else if (operation === ' ') { + addCount++; + removeCount++; + } + } else { + break; + } + } + + // Handle the empty block count case + if (!addCount && hunk.newLines === 1) { + hunk.newLines = 0; + } + if (!removeCount && hunk.oldLines === 1) { + hunk.oldLines = 0; + } + + // Perform optional sanity checking + if (options.strict) { + if (addCount !== hunk.newLines) { + throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); + } + if (removeCount !== hunk.oldLines) { + throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1)); + } + } + + return hunk; + } + + while (i < diffstr.length) { + parseIndex(); + } + + return list; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/parse.js"],"names":["parsePatch","uniDiff","options","diffstr","split","delimiters","match","list","i","parseIndex","index","push","length","line","test","header","exec","parseFileHeader","hunks","parseHunk","strict","Error","JSON","stringify","fileHeader","keyPrefix","data","fileName","replace","substr","trim","chunkHeaderIndex","chunkHeaderLine","chunkHeader","hunk","oldStart","oldLines","newStart","newLines","lines","linedelimiters","addCount","removeCount","indexOf","operation"],"mappings":";;;gCAAgBA,U,GAAAA,U;AAAT,SAASA,UAAT,CAAoBC,OAApB,EAA2C;AAAA,sDAAdC,OAAc,uEAAJ,EAAI;;AAChD,MAAIC,UAAUF,QAAQG,KAAR,CAAc,qBAAd,CAAd;AAAA,MACIC,aAAaJ,QAAQK,KAAR,CAAc,sBAAd,KAAyC,EAD1D;AAAA,MAEIC,OAAO,EAFX;AAAA,MAGIC,IAAI,CAHR;;AAKA,WAASC,UAAT,GAAsB;AACpB,QAAIC,QAAQ,EAAZ;AACAH,SAAKI,IAAL,CAAUD,KAAV;;AAEA;AACA,WAAOF,IAAIL,QAAQS,MAAnB,EAA2B;AACzB,UAAIC,OAAOV,QAAQK,CAAR,CAAX;;AAEA;AACA,UAAI,wBAAwBM,IAAxB,CAA6BD,IAA7B,CAAJ,EAAwC;AACtC;AACD;;AAED;AACA,UAAIE,SAAU,0CAAD,CAA6CC,IAA7C,CAAkDH,IAAlD,CAAb;AACA,UAAIE,MAAJ,EAAY;AACVL,cAAMA,KAAN,GAAcK,OAAO,CAAP,CAAd;AACD;;AAEDP;AACD;;AAED;AACA;AACAS,oBAAgBP,KAAhB;AACAO,oBAAgBP,KAAhB;;AAEA;AACAA,UAAMQ,KAAN,GAAc,EAAd;;AAEA,WAAOV,IAAIL,QAAQS,MAAnB,EAA2B;AACzB,UAAIC,QAAOV,QAAQK,CAAR,CAAX;;AAEA,UAAI,iCAAiCM,IAAjC,CAAsCD,KAAtC,CAAJ,EAAiD;AAC/C;AACD,OAFD,MAEO,IAAI,MAAMC,IAAN,CAAWD,KAAX,CAAJ,EAAsB;AAC3BH,cAAMQ,KAAN,CAAYP,IAAZ,CAAiBQ,WAAjB;AACD,OAFM,MAEA,IAAIN,SAAQX,QAAQkB,MAApB,EAA4B;AACjC;AACA,cAAM,IAAIC,KAAJ,CAAU,mBAAmBb,IAAI,CAAvB,IAA4B,GAA5B,GAAkCc,KAAKC,SAAL,CAAeV,KAAf,CAA5C,CAAN;AACD,OAHM,MAGA;AACLL;AACD;AACF;AACF;;AAED;AACA;AACA,WAASS,eAAT,CAAyBP,KAAzB,EAAgC;AAC9B,QAAMc,aAAc,uBAAD,CAA0BR,IAA1B,CAA+Bb,QAAQK,CAAR,CAA/B,CAAnB;AACA,QAAIgB,UAAJ,EAAgB;AACd,UAAIC,YAAYD,WAAW,CAAX,MAAkB,KAAlB,GAA0B,KAA1B,GAAkC,KAAlD;AACA,UAAME,OAAOF,WAAW,CAAX,EAAcpB,KAAd,CAAoB,IAApB,EAA0B,CAA1B,CAAb;AACA,UAAIuB,WAAWD,KAAK,CAAL,EAAQE,OAAR,CAAgB,OAAhB,EAAyB,IAAzB,CAAf;AACA,UAAI,SAASd,IAAT,CAAca,QAAd,CAAJ,EAA6B;AAC3BA,mBAAWA,SAASE,MAAT,CAAgB,CAAhB,EAAmBF,SAASf,MAAT,GAAkB,CAArC,CAAX;AACD;AACDF,YAAMe,YAAY,UAAlB,IAAgCE,QAAhC;AACAjB,YAAMe,YAAY,QAAlB,IAA8B,CAACC,KAAK,CAAL,KAAW,EAAZ,EAAgBI,IAAhB,EAA9B;;AAEAtB;AACD;AACF;;AAED;AACA;AACA,WAASW,SAAT,GAAqB;AACnB,QAAIY,mBAAmBvB,CAAvB;AAAA,QACIwB,kBAAkB7B,QAAQK,GAAR,CADtB;AAAA,QAEIyB,cAAcD,gBAAgB5B,KAAhB,CAAsB,4CAAtB,CAFlB;;AAIA,QAAI8B,OAAO;AACTC,gBAAU,CAACF,YAAY,CAAZ,CADF;AAETG,gBAAU,CAACH,YAAY,CAAZ,CAAD,IAAmB,CAFpB;AAGTI,gBAAU,CAACJ,YAAY,CAAZ,CAHF;AAITK,gBAAU,CAACL,YAAY,CAAZ,CAAD,IAAmB,CAJpB;AAKTM,aAAO,EALE;AAMTC,sBAAgB;AANP,KAAX;;AASA,QAAIC,WAAW,CAAf;AAAA,QACIC,cAAc,CADlB;AAEA,WAAOlC,IAAIL,QAAQS,MAAnB,EAA2BJ,GAA3B,EAAgC;AAC9B;AACA;AACA,UAAIL,QAAQK,CAAR,EAAWmC,OAAX,CAAmB,MAAnB,MAA+B,CAA/B,IACMnC,IAAI,CAAJ,GAAQL,QAAQS,MADtB,IAEKT,QAAQK,IAAI,CAAZ,EAAemC,OAAf,CAAuB,MAAvB,MAAmC,CAFxC,IAGKxC,QAAQK,IAAI,CAAZ,EAAemC,OAAf,CAAuB,IAAvB,MAAiC,CAH1C,EAG6C;AACzC;AACH;AACD,UAAIC,YAAazC,QAAQK,CAAR,EAAWI,MAAX,IAAqB,CAArB,IAA0BJ,KAAML,QAAQS,MAAR,GAAiB,CAAlD,GAAwD,GAAxD,GAA8DT,QAAQK,CAAR,EAAW,CAAX,CAA9E;;AAEA,UAAIoC,cAAc,GAAd,IAAqBA,cAAc,GAAnC,IAA0CA,cAAc,GAAxD,IAA+DA,cAAc,IAAjF,EAAuF;AACrFV,aAAKK,KAAL,CAAW5B,IAAX,CAAgBR,QAAQK,CAAR,CAAhB;AACA0B,aAAKM,cAAL,CAAoB7B,IAApB,CAAyBN,WAAWG,CAAX,KAAiB,IAA1C;;AAEA,YAAIoC,cAAc,GAAlB,EAAuB;AACrBH;AACD,SAFD,MAEO,IAAIG,cAAc,GAAlB,EAAuB;AAC5BF;AACD,SAFM,MAEA,IAAIE,cAAc,GAAlB,EAAuB;AAC5BH;AACAC;AACD;AACF,OAZD,MAYO;AACL;AACD;AACF;;AAED;AACA,QAAI,CAACD,QAAD,IAAaP,KAAKI,QAAL,KAAkB,CAAnC,EAAsC;AACpCJ,WAAKI,QAAL,GAAgB,CAAhB;AACD;AACD,QAAI,CAACI,WAAD,IAAgBR,KAAKE,QAAL,KAAkB,CAAtC,EAAyC;AACvCF,WAAKE,QAAL,GAAgB,CAAhB;AACD;;AAED;AACA,QAAIlC,QAAQkB,MAAZ,EAAoB;AAClB,UAAIqB,aAAaP,KAAKI,QAAtB,EAAgC;AAC9B,cAAM,IAAIjB,KAAJ,CAAU,sDAAsDU,mBAAmB,CAAzE,CAAV,CAAN;AACD;AACD,UAAIW,gBAAgBR,KAAKE,QAAzB,EAAmC;AACjC,cAAM,IAAIf,KAAJ,CAAU,wDAAwDU,mBAAmB,CAA3E,CAAV,CAAN;AACD;AACF;;AAED,WAAOG,IAAP;AACD;;AAED,SAAO1B,IAAIL,QAAQS,MAAnB,EAA2B;AACzBH;AACD;;AAED,SAAOF,IAAP;AACD","file":"parse.js","sourcesContent":["export function parsePatch(uniDiff, options = {}) {\n  let diffstr = uniDiff.split(/\\r\\n|[\\n\\v\\f\\r\\x85]/),\n      delimiters = uniDiff.match(/\\r\\n|[\\n\\v\\f\\r\\x85]/g) || [],\n      list = [],\n      i = 0;\n\n  function parseIndex() {\n    let index = {};\n    list.push(index);\n\n    // Parse diff metadata\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      // File header found, end parsing diff metadata\n      if (/^(\\-\\-\\-|\\+\\+\\+|@@)\\s/.test(line)) {\n        break;\n      }\n\n      // Diff index\n      let header = (/^(?:Index:|diff(?: -r \\w+)+)\\s+(.+?)\\s*$/).exec(line);\n      if (header) {\n        index.index = header[1];\n      }\n\n      i++;\n    }\n\n    // Parse file headers if they are defined. Unified diff requires them, but\n    // there's no technical issues to have an isolated hunk without file header\n    parseFileHeader(index);\n    parseFileHeader(index);\n\n    // Parse hunks\n    index.hunks = [];\n\n    while (i < diffstr.length) {\n      let line = diffstr[i];\n\n      if (/^(Index:|diff|\\-\\-\\-|\\+\\+\\+)\\s/.test(line)) {\n        break;\n      } else if (/^@@/.test(line)) {\n        index.hunks.push(parseHunk());\n      } else if (line && options.strict) {\n        // Ignore unexpected content unless in strict mode\n        throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(line));\n      } else {\n        i++;\n      }\n    }\n  }\n\n  // Parses the --- and +++ headers, if none are found, no lines\n  // are consumed.\n  function parseFileHeader(index) {\n    const fileHeader = (/^(---|\\+\\+\\+)\\s+(.*)$/).exec(diffstr[i]);\n    if (fileHeader) {\n      let keyPrefix = fileHeader[1] === '---' ? 'old' : 'new';\n      const data = fileHeader[2].split('\\t', 2);\n      let fileName = data[0].replace(/\\\\\\\\/g, '\\\\');\n      if (/^\".*\"$/.test(fileName)) {\n        fileName = fileName.substr(1, fileName.length - 2);\n      }\n      index[keyPrefix + 'FileName'] = fileName;\n      index[keyPrefix + 'Header'] = (data[1] || '').trim();\n\n      i++;\n    }\n  }\n\n  // Parses a hunk\n  // This assumes that we are at the start of a hunk.\n  function parseHunk() {\n    let chunkHeaderIndex = i,\n        chunkHeaderLine = diffstr[i++],\n        chunkHeader = chunkHeaderLine.split(/@@ -(\\d+)(?:,(\\d+))? \\+(\\d+)(?:,(\\d+))? @@/);\n\n    let hunk = {\n      oldStart: +chunkHeader[1],\n      oldLines: +chunkHeader[2] || 1,\n      newStart: +chunkHeader[3],\n      newLines: +chunkHeader[4] || 1,\n      lines: [],\n      linedelimiters: []\n    };\n\n    let addCount = 0,\n        removeCount = 0;\n    for (; i < diffstr.length; i++) {\n      // Lines starting with '---' could be mistaken for the \"remove line\" operation\n      // But they could be the header for the next file. Therefore prune such cases out.\n      if (diffstr[i].indexOf('--- ') === 0\n            && (i + 2 < diffstr.length)\n            && diffstr[i + 1].indexOf('+++ ') === 0\n            && diffstr[i + 2].indexOf('@@') === 0) {\n          break;\n      }\n      let operation = (diffstr[i].length == 0 && i != (diffstr.length - 1)) ? ' ' : diffstr[i][0];\n\n      if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\\\') {\n        hunk.lines.push(diffstr[i]);\n        hunk.linedelimiters.push(delimiters[i] || '\\n');\n\n        if (operation === '+') {\n          addCount++;\n        } else if (operation === '-') {\n          removeCount++;\n        } else if (operation === ' ') {\n          addCount++;\n          removeCount++;\n        }\n      } else {\n        break;\n      }\n    }\n\n    // Handle the empty block count case\n    if (!addCount && hunk.newLines === 1) {\n      hunk.newLines = 0;\n    }\n    if (!removeCount && hunk.oldLines === 1) {\n      hunk.oldLines = 0;\n    }\n\n    // Perform optional sanity checking\n    if (options.strict) {\n      if (addCount !== hunk.newLines) {\n        throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n      if (removeCount !== hunk.oldLines) {\n        throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));\n      }\n    }\n\n    return hunk;\n  }\n\n  while (i < diffstr.length) {\n    parseIndex();\n  }\n\n  return list;\n}\n"]} + + +/***/ }), +/* 12 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + + exports["default"] = /*istanbul ignore end*/function (start, minLine, maxLine) { + var wantForward = true, + backwardExhausted = false, + forwardExhausted = false, + localOffset = 1; + + return function iterator() { + if (wantForward && !forwardExhausted) { + if (backwardExhausted) { + localOffset++; + } else { + wantForward = false; + } + + // Check if trying to fit beyond text length, and if not, check it fits + // after offset location (or desired location on first iteration) + if (start + localOffset <= maxLine) { + return localOffset; + } + + forwardExhausted = true; + } + + if (!backwardExhausted) { + if (!forwardExhausted) { + wantForward = true; + } + + // Check if trying to fit before text beginning, and if not, check it fits + // before offset location + if (minLine <= start - localOffset) { + return -localOffset++; + } + + backwardExhausted = true; + return iterator(); + } + + // We tried to fit hunk before text beginning and beyond text length, then + // hunk can't fit on the text. Return undefined + }; + }; + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL2Rpc3RhbmNlLWl0ZXJhdG9yLmpzIl0sIm5hbWVzIjpbInN0YXJ0IiwibWluTGluZSIsIm1heExpbmUiLCJ3YW50Rm9yd2FyZCIsImJhY2t3YXJkRXhoYXVzdGVkIiwiZm9yd2FyZEV4aGF1c3RlZCIsImxvY2FsT2Zmc2V0IiwiaXRlcmF0b3IiXSwibWFwcGluZ3MiOiI7Ozs7NENBR2UsVUFBU0EsS0FBVCxFQUFnQkMsT0FBaEIsRUFBeUJDLE9BQXpCLEVBQWtDO0FBQy9DLE1BQUlDLGNBQWMsSUFBbEI7QUFBQSxNQUNJQyxvQkFBb0IsS0FEeEI7QUFBQSxNQUVJQyxtQkFBbUIsS0FGdkI7QUFBQSxNQUdJQyxjQUFjLENBSGxCOztBQUtBLFNBQU8sU0FBU0MsUUFBVCxHQUFvQjtBQUN6QixRQUFJSixlQUFlLENBQUNFLGdCQUFwQixFQUFzQztBQUNwQyxVQUFJRCxpQkFBSixFQUF1QjtBQUNyQkU7QUFDRCxPQUZELE1BRU87QUFDTEgsc0JBQWMsS0FBZDtBQUNEOztBQUVEO0FBQ0E7QUFDQSxVQUFJSCxRQUFRTSxXQUFSLElBQXVCSixPQUEzQixFQUFvQztBQUNsQyxlQUFPSSxXQUFQO0FBQ0Q7O0FBRURELHlCQUFtQixJQUFuQjtBQUNEOztBQUVELFFBQUksQ0FBQ0QsaUJBQUwsRUFBd0I7QUFDdEIsVUFBSSxDQUFDQyxnQkFBTCxFQUF1QjtBQUNyQkYsc0JBQWMsSUFBZDtBQUNEOztBQUVEO0FBQ0E7QUFDQSxVQUFJRixXQUFXRCxRQUFRTSxXQUF2QixFQUFvQztBQUNsQyxlQUFPLENBQUNBLGFBQVI7QUFDRDs7QUFFREYsMEJBQW9CLElBQXBCO0FBQ0EsYUFBT0csVUFBUDtBQUNEOztBQUVEO0FBQ0E7QUFDRCxHQWxDRDtBQW1DRCxDIiwiZmlsZSI6ImRpc3RhbmNlLWl0ZXJhdG9yLmpzIiwic291cmNlc0NvbnRlbnQiOlsiLy8gSXRlcmF0b3IgdGhhdCB0cmF2ZXJzZXMgaW4gdGhlIHJhbmdlIG9mIFttaW4sIG1heF0sIHN0ZXBwaW5nXG4vLyBieSBkaXN0YW5jZSBmcm9tIGEgZ2l2ZW4gc3RhcnQgcG9zaXRpb24uIEkuZS4gZm9yIFswLCA0XSwgd2l0aFxuLy8gc3RhcnQgb2YgMiwgdGhpcyB3aWxsIGl0ZXJhdGUgMiwgMywgMSwgNCwgMC5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uKHN0YXJ0LCBtaW5MaW5lLCBtYXhMaW5lKSB7XG4gIGxldCB3YW50Rm9yd2FyZCA9IHRydWUsXG4gICAgICBiYWNrd2FyZEV4aGF1c3RlZCA9IGZhbHNlLFxuICAgICAgZm9yd2FyZEV4aGF1c3RlZCA9IGZhbHNlLFxuICAgICAgbG9jYWxPZmZzZXQgPSAxO1xuXG4gIHJldHVybiBmdW5jdGlvbiBpdGVyYXRvcigpIHtcbiAgICBpZiAod2FudEZvcndhcmQgJiYgIWZvcndhcmRFeGhhdXN0ZWQpIHtcbiAgICAgIGlmIChiYWNrd2FyZEV4aGF1c3RlZCkge1xuICAgICAgICBsb2NhbE9mZnNldCsrO1xuICAgICAgfSBlbHNlIHtcbiAgICAgICAgd2FudEZvcndhcmQgPSBmYWxzZTtcbiAgICAgIH1cblxuICAgICAgLy8gQ2hlY2sgaWYgdHJ5aW5nIHRvIGZpdCBiZXlvbmQgdGV4dCBsZW5ndGgsIGFuZCBpZiBub3QsIGNoZWNrIGl0IGZpdHNcbiAgICAgIC8vIGFmdGVyIG9mZnNldCBsb2NhdGlvbiAob3IgZGVzaXJlZCBsb2NhdGlvbiBvbiBmaXJzdCBpdGVyYXRpb24pXG4gICAgICBpZiAoc3RhcnQgKyBsb2NhbE9mZnNldCA8PSBtYXhMaW5lKSB7XG4gICAgICAgIHJldHVybiBsb2NhbE9mZnNldDtcbiAgICAgIH1cblxuICAgICAgZm9yd2FyZEV4aGF1c3RlZCA9IHRydWU7XG4gICAgfVxuXG4gICAgaWYgKCFiYWNrd2FyZEV4aGF1c3RlZCkge1xuICAgICAgaWYgKCFmb3J3YXJkRXhoYXVzdGVkKSB7XG4gICAgICAgIHdhbnRGb3J3YXJkID0gdHJ1ZTtcbiAgICAgIH1cblxuICAgICAgLy8gQ2hlY2sgaWYgdHJ5aW5nIHRvIGZpdCBiZWZvcmUgdGV4dCBiZWdpbm5pbmcsIGFuZCBpZiBub3QsIGNoZWNrIGl0IGZpdHNcbiAgICAgIC8vIGJlZm9yZSBvZmZzZXQgbG9jYXRpb25cbiAgICAgIGlmIChtaW5MaW5lIDw9IHN0YXJ0IC0gbG9jYWxPZmZzZXQpIHtcbiAgICAgICAgcmV0dXJuIC1sb2NhbE9mZnNldCsrO1xuICAgICAgfVxuXG4gICAgICBiYWNrd2FyZEV4aGF1c3RlZCA9IHRydWU7XG4gICAgICByZXR1cm4gaXRlcmF0b3IoKTtcbiAgICB9XG5cbiAgICAvLyBXZSB0cmllZCB0byBmaXQgaHVuayBiZWZvcmUgdGV4dCBiZWdpbm5pbmcgYW5kIGJleW9uZCB0ZXh0IGxlbmd0aCwgdGhlblxuICAgIC8vIGh1bmsgY2FuJ3QgZml0IG9uIHRoZSB0ZXh0LiBSZXR1cm4gdW5kZWZpbmVkXG4gIH07XG59XG4iXX0= + + +/***/ }), +/* 13 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/calcLineCount = calcLineCount; + /*istanbul ignore start*/exports. /*istanbul ignore end*/merge = merge; + + var /*istanbul ignore start*/_create = __webpack_require__(14) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_parse = __webpack_require__(11) /*istanbul ignore end*/; + + var /*istanbul ignore start*/_array = __webpack_require__(15) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + + /*istanbul ignore end*/function calcLineCount(hunk) { + /*istanbul ignore start*/var _calcOldNewLineCount = /*istanbul ignore end*/calcOldNewLineCount(hunk.lines), + oldLines = _calcOldNewLineCount.oldLines, + newLines = _calcOldNewLineCount.newLines; + + if (oldLines !== undefined) { + hunk.oldLines = oldLines; + } else { + delete hunk.oldLines; + } + + if (newLines !== undefined) { + hunk.newLines = newLines; + } else { + delete hunk.newLines; + } + } + + function merge(mine, theirs, base) { + mine = loadPatch(mine, base); + theirs = loadPatch(theirs, base); + + var ret = {}; + + // For index we just let it pass through as it doesn't have any necessary meaning. + // Leaving sanity checks on this to the API consumer that may know more about the + // meaning in their own context. + if (mine.index || theirs.index) { + ret.index = mine.index || theirs.index; + } + + if (mine.newFileName || theirs.newFileName) { + if (!fileNameChanged(mine)) { + // No header or no change in ours, use theirs (and ours if theirs does not exist) + ret.oldFileName = theirs.oldFileName || mine.oldFileName; + ret.newFileName = theirs.newFileName || mine.newFileName; + ret.oldHeader = theirs.oldHeader || mine.oldHeader; + ret.newHeader = theirs.newHeader || mine.newHeader; + } else if (!fileNameChanged(theirs)) { + // No header or no change in theirs, use ours + ret.oldFileName = mine.oldFileName; + ret.newFileName = mine.newFileName; + ret.oldHeader = mine.oldHeader; + ret.newHeader = mine.newHeader; + } else { + // Both changed... figure it out + ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName); + ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName); + ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader); + ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader); + } + } + + ret.hunks = []; + + var mineIndex = 0, + theirsIndex = 0, + mineOffset = 0, + theirsOffset = 0; + + while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) { + var mineCurrent = mine.hunks[mineIndex] || { oldStart: Infinity }, + theirsCurrent = theirs.hunks[theirsIndex] || { oldStart: Infinity }; + + if (hunkBefore(mineCurrent, theirsCurrent)) { + // This patch does not overlap with any of the others, yay. + ret.hunks.push(cloneHunk(mineCurrent, mineOffset)); + mineIndex++; + theirsOffset += mineCurrent.newLines - mineCurrent.oldLines; + } else if (hunkBefore(theirsCurrent, mineCurrent)) { + // This patch does not overlap with any of the others, yay. + ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset)); + theirsIndex++; + mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines; + } else { + // Overlap, merge as best we can + var mergedHunk = { + oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart), + oldLines: 0, + newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset), + newLines: 0, + lines: [] + }; + mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines); + theirsIndex++; + mineIndex++; + + ret.hunks.push(mergedHunk); + } + } + + return ret; + } + + function loadPatch(param, base) { + if (typeof param === 'string') { + if (/^@@/m.test(param) || /^Index:/m.test(param)) { + return (/*istanbul ignore start*/(0, _parse.parsePatch) /*istanbul ignore end*/(param)[0] + ); + } + + if (!base) { + throw new Error('Must provide a base reference or pass in a patch'); + } + return (/*istanbul ignore start*/(0, _create.structuredPatch) /*istanbul ignore end*/(undefined, undefined, base, param) + ); + } + + return param; + } + + function fileNameChanged(patch) { + return patch.newFileName && patch.newFileName !== patch.oldFileName; + } + + function selectField(index, mine, theirs) { + if (mine === theirs) { + return mine; + } else { + index.conflict = true; + return { mine: mine, theirs: theirs }; + } + } + + function hunkBefore(test, check) { + return test.oldStart < check.oldStart && test.oldStart + test.oldLines < check.oldStart; + } + + function cloneHunk(hunk, offset) { + return { + oldStart: hunk.oldStart, oldLines: hunk.oldLines, + newStart: hunk.newStart + offset, newLines: hunk.newLines, + lines: hunk.lines + }; + } + + function mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) { + // This will generally result in a conflicted hunk, but there are cases where the context + // is the only overlap where we can successfully merge the content here. + var mine = { offset: mineOffset, lines: mineLines, index: 0 }, + their = { offset: theirOffset, lines: theirLines, index: 0 }; + + // Handle any leading content + insertLeading(hunk, mine, their); + insertLeading(hunk, their, mine); + + // Now in the overlap content. Scan through and select the best changes from each. + while (mine.index < mine.lines.length && their.index < their.lines.length) { + var mineCurrent = mine.lines[mine.index], + theirCurrent = their.lines[their.index]; + + if ((mineCurrent[0] === '-' || mineCurrent[0] === '+') && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) { + // Both modified ... + mutualChange(hunk, mine, their); + } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') { + /*istanbul ignore start*/var _hunk$lines; + + /*istanbul ignore end*/ // Mine inserted + /*istanbul ignore start*/(_hunk$lines = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/collectChange(mine))); + } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') { + /*istanbul ignore start*/var _hunk$lines2; + + /*istanbul ignore end*/ // Theirs inserted + /*istanbul ignore start*/(_hunk$lines2 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/collectChange(their))); + } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') { + // Mine removed or edited + removal(hunk, mine, their); + } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') { + // Their removed or edited + removal(hunk, their, mine, true); + } else if (mineCurrent === theirCurrent) { + // Context identity + hunk.lines.push(mineCurrent); + mine.index++; + their.index++; + } else { + // Context mismatch + conflict(hunk, collectChange(mine), collectChange(their)); + } + } + + // Now push anything that may be remaining + insertTrailing(hunk, mine); + insertTrailing(hunk, their); + + calcLineCount(hunk); + } + + function mutualChange(hunk, mine, their) { + var myChanges = collectChange(mine), + theirChanges = collectChange(their); + + if (allRemoves(myChanges) && allRemoves(theirChanges)) { + // Special case for remove changes that are supersets of one another + if ( /*istanbul ignore start*/(0, _array.arrayStartsWith) /*istanbul ignore end*/(myChanges, theirChanges) && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) { + /*istanbul ignore start*/var _hunk$lines3; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines3 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/myChanges)); + return; + } else if ( /*istanbul ignore start*/(0, _array.arrayStartsWith) /*istanbul ignore end*/(theirChanges, myChanges) && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) { + /*istanbul ignore start*/var _hunk$lines4; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines4 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines4 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/theirChanges)); + return; + } + } else if ( /*istanbul ignore start*/(0, _array.arrayEqual) /*istanbul ignore end*/(myChanges, theirChanges)) { + /*istanbul ignore start*/var _hunk$lines5; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines5 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines5 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/myChanges)); + return; + } + + conflict(hunk, myChanges, theirChanges); + } + + function removal(hunk, mine, their, swap) { + var myChanges = collectChange(mine), + theirChanges = collectContext(their, myChanges); + if (theirChanges.merged) { + /*istanbul ignore start*/var _hunk$lines6; + + /*istanbul ignore end*/ /*istanbul ignore start*/(_hunk$lines6 = /*istanbul ignore end*/hunk.lines).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_hunk$lines6 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/theirChanges.merged)); + } else { + conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges); + } + } + + function conflict(hunk, mine, their) { + hunk.conflict = true; + hunk.lines.push({ + conflict: true, + mine: mine, + theirs: their + }); + } + + function insertLeading(hunk, insert, their) { + while (insert.offset < their.offset && insert.index < insert.lines.length) { + var line = insert.lines[insert.index++]; + hunk.lines.push(line); + insert.offset++; + } + } + function insertTrailing(hunk, insert) { + while (insert.index < insert.lines.length) { + var line = insert.lines[insert.index++]; + hunk.lines.push(line); + } + } + + function collectChange(state) { + var ret = [], + operation = state.lines[state.index][0]; + while (state.index < state.lines.length) { + var line = state.lines[state.index]; + + // Group additions that are immediately after subtractions and treat them as one "atomic" modify change. + if (operation === '-' && line[0] === '+') { + operation = '+'; + } + + if (operation === line[0]) { + ret.push(line); + state.index++; + } else { + break; + } + } + + return ret; + } + function collectContext(state, matchChanges) { + var changes = [], + merged = [], + matchIndex = 0, + contextChanges = false, + conflicted = false; + while (matchIndex < matchChanges.length && state.index < state.lines.length) { + var change = state.lines[state.index], + match = matchChanges[matchIndex]; + + // Once we've hit our add, then we are done + if (match[0] === '+') { + break; + } + + contextChanges = contextChanges || change[0] !== ' '; + + merged.push(match); + matchIndex++; + + // Consume any additions in the other block as a conflict to attempt + // to pull in the remaining context after this + if (change[0] === '+') { + conflicted = true; + + while (change[0] === '+') { + changes.push(change); + change = state.lines[++state.index]; + } + } + + if (match.substr(1) === change.substr(1)) { + changes.push(change); + state.index++; + } else { + conflicted = true; + } + } + + if ((matchChanges[matchIndex] || '')[0] === '+' && contextChanges) { + conflicted = true; + } + + if (conflicted) { + return changes; + } + + while (matchIndex < matchChanges.length) { + merged.push(matchChanges[matchIndex++]); + } + + return { + merged: merged, + changes: changes + }; + } + + function allRemoves(changes) { + return changes.reduce(function (prev, change) { + return prev && change[0] === '-'; + }, true); + } + function skipRemoveSuperset(state, removeChanges, delta) { + for (var i = 0; i < delta; i++) { + var changeContent = removeChanges[removeChanges.length - delta + i].substr(1); + if (state.lines[state.index + i] !== ' ' + changeContent) { + return false; + } + } + + state.index += delta; + return true; + } + + function calcOldNewLineCount(lines) { + var oldLines = 0; + var newLines = 0; + + lines.forEach(function (line) { + if (typeof line !== 'string') { + var myCount = calcOldNewLineCount(line.mine); + var theirCount = calcOldNewLineCount(line.theirs); + + if (oldLines !== undefined) { + if (myCount.oldLines === theirCount.oldLines) { + oldLines += myCount.oldLines; + } else { + oldLines = undefined; + } + } + + if (newLines !== undefined) { + if (myCount.newLines === theirCount.newLines) { + newLines += myCount.newLines; + } else { + newLines = undefined; + } + } + } else { + if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) { + newLines++; + } + if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) { + oldLines++; + } + } + }); + + return { oldLines: oldLines, newLines: newLines }; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/merge.js"],"names":["calcLineCount","merge","hunk","calcOldNewLineCount","lines","oldLines","newLines","undefined","mine","theirs","base","loadPatch","ret","index","newFileName","fileNameChanged","oldFileName","oldHeader","newHeader","selectField","hunks","mineIndex","theirsIndex","mineOffset","theirsOffset","length","mineCurrent","oldStart","Infinity","theirsCurrent","hunkBefore","push","cloneHunk","mergedHunk","Math","min","newStart","mergeLines","param","test","Error","patch","conflict","check","offset","mineLines","theirOffset","theirLines","their","insertLeading","theirCurrent","mutualChange","collectChange","removal","insertTrailing","myChanges","theirChanges","allRemoves","skipRemoveSuperset","swap","collectContext","merged","insert","line","state","operation","matchChanges","changes","matchIndex","contextChanges","conflicted","change","match","substr","reduce","prev","removeChanges","delta","i","changeContent","forEach","myCount","theirCount"],"mappings":"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","file":"merge.js","sourcesContent":["import {structuredPatch} from './create';\nimport {parsePatch} from './parse';\n\nimport {arrayEqual, arrayStartsWith} from '../util/array';\n\nexport function calcLineCount(hunk) {\n  const {oldLines, newLines} = calcOldNewLineCount(hunk.lines);\n\n  if (oldLines !== undefined) {\n    hunk.oldLines = oldLines;\n  } else {\n    delete hunk.oldLines;\n  }\n\n  if (newLines !== undefined) {\n    hunk.newLines = newLines;\n  } else {\n    delete hunk.newLines;\n  }\n}\n\nexport function merge(mine, theirs, base) {\n  mine = loadPatch(mine, base);\n  theirs = loadPatch(theirs, base);\n\n  let ret = {};\n\n  // For index we just let it pass through as it doesn't have any necessary meaning.\n  // Leaving sanity checks on this to the API consumer that may know more about the\n  // meaning in their own context.\n  if (mine.index || theirs.index) {\n    ret.index = mine.index || theirs.index;\n  }\n\n  if (mine.newFileName || theirs.newFileName) {\n    if (!fileNameChanged(mine)) {\n      // No header or no change in ours, use theirs (and ours if theirs does not exist)\n      ret.oldFileName = theirs.oldFileName || mine.oldFileName;\n      ret.newFileName = theirs.newFileName || mine.newFileName;\n      ret.oldHeader = theirs.oldHeader || mine.oldHeader;\n      ret.newHeader = theirs.newHeader || mine.newHeader;\n    } else if (!fileNameChanged(theirs)) {\n      // No header or no change in theirs, use ours\n      ret.oldFileName = mine.oldFileName;\n      ret.newFileName = mine.newFileName;\n      ret.oldHeader = mine.oldHeader;\n      ret.newHeader = mine.newHeader;\n    } else {\n      // Both changed... figure it out\n      ret.oldFileName = selectField(ret, mine.oldFileName, theirs.oldFileName);\n      ret.newFileName = selectField(ret, mine.newFileName, theirs.newFileName);\n      ret.oldHeader = selectField(ret, mine.oldHeader, theirs.oldHeader);\n      ret.newHeader = selectField(ret, mine.newHeader, theirs.newHeader);\n    }\n  }\n\n  ret.hunks = [];\n\n  let mineIndex = 0,\n      theirsIndex = 0,\n      mineOffset = 0,\n      theirsOffset = 0;\n\n  while (mineIndex < mine.hunks.length || theirsIndex < theirs.hunks.length) {\n    let mineCurrent = mine.hunks[mineIndex] || {oldStart: Infinity},\n        theirsCurrent = theirs.hunks[theirsIndex] || {oldStart: Infinity};\n\n    if (hunkBefore(mineCurrent, theirsCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(mineCurrent, mineOffset));\n      mineIndex++;\n      theirsOffset += mineCurrent.newLines - mineCurrent.oldLines;\n    } else if (hunkBefore(theirsCurrent, mineCurrent)) {\n      // This patch does not overlap with any of the others, yay.\n      ret.hunks.push(cloneHunk(theirsCurrent, theirsOffset));\n      theirsIndex++;\n      mineOffset += theirsCurrent.newLines - theirsCurrent.oldLines;\n    } else {\n      // Overlap, merge as best we can\n      let mergedHunk = {\n        oldStart: Math.min(mineCurrent.oldStart, theirsCurrent.oldStart),\n        oldLines: 0,\n        newStart: Math.min(mineCurrent.newStart + mineOffset, theirsCurrent.oldStart + theirsOffset),\n        newLines: 0,\n        lines: []\n      };\n      mergeLines(mergedHunk, mineCurrent.oldStart, mineCurrent.lines, theirsCurrent.oldStart, theirsCurrent.lines);\n      theirsIndex++;\n      mineIndex++;\n\n      ret.hunks.push(mergedHunk);\n    }\n  }\n\n  return ret;\n}\n\nfunction loadPatch(param, base) {\n  if (typeof param === 'string') {\n    if (/^@@/m.test(param) || (/^Index:/m.test(param))) {\n      return parsePatch(param)[0];\n    }\n\n    if (!base) {\n      throw new Error('Must provide a base reference or pass in a patch');\n    }\n    return structuredPatch(undefined, undefined, base, param);\n  }\n\n  return param;\n}\n\nfunction fileNameChanged(patch) {\n  return patch.newFileName && patch.newFileName !== patch.oldFileName;\n}\n\nfunction selectField(index, mine, theirs) {\n  if (mine === theirs) {\n    return mine;\n  } else {\n    index.conflict = true;\n    return {mine, theirs};\n  }\n}\n\nfunction hunkBefore(test, check) {\n  return test.oldStart < check.oldStart\n    && (test.oldStart + test.oldLines) < check.oldStart;\n}\n\nfunction cloneHunk(hunk, offset) {\n  return {\n    oldStart: hunk.oldStart, oldLines: hunk.oldLines,\n    newStart: hunk.newStart + offset, newLines: hunk.newLines,\n    lines: hunk.lines\n  };\n}\n\nfunction mergeLines(hunk, mineOffset, mineLines, theirOffset, theirLines) {\n  // This will generally result in a conflicted hunk, but there are cases where the context\n  // is the only overlap where we can successfully merge the content here.\n  let mine = {offset: mineOffset, lines: mineLines, index: 0},\n      their = {offset: theirOffset, lines: theirLines, index: 0};\n\n  // Handle any leading content\n  insertLeading(hunk, mine, their);\n  insertLeading(hunk, their, mine);\n\n  // Now in the overlap content. Scan through and select the best changes from each.\n  while (mine.index < mine.lines.length && their.index < their.lines.length) {\n    let mineCurrent = mine.lines[mine.index],\n        theirCurrent = their.lines[their.index];\n\n    if ((mineCurrent[0] === '-' || mineCurrent[0] === '+')\n        && (theirCurrent[0] === '-' || theirCurrent[0] === '+')) {\n      // Both modified ...\n      mutualChange(hunk, mine, their);\n    } else if (mineCurrent[0] === '+' && theirCurrent[0] === ' ') {\n      // Mine inserted\n      hunk.lines.push(... collectChange(mine));\n    } else if (theirCurrent[0] === '+' && mineCurrent[0] === ' ') {\n      // Theirs inserted\n      hunk.lines.push(... collectChange(their));\n    } else if (mineCurrent[0] === '-' && theirCurrent[0] === ' ') {\n      // Mine removed or edited\n      removal(hunk, mine, their);\n    } else if (theirCurrent[0] === '-' && mineCurrent[0] === ' ') {\n      // Their removed or edited\n      removal(hunk, their, mine, true);\n    } else if (mineCurrent === theirCurrent) {\n      // Context identity\n      hunk.lines.push(mineCurrent);\n      mine.index++;\n      their.index++;\n    } else {\n      // Context mismatch\n      conflict(hunk, collectChange(mine), collectChange(their));\n    }\n  }\n\n  // Now push anything that may be remaining\n  insertTrailing(hunk, mine);\n  insertTrailing(hunk, their);\n\n  calcLineCount(hunk);\n}\n\nfunction mutualChange(hunk, mine, their) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectChange(their);\n\n  if (allRemoves(myChanges) && allRemoves(theirChanges)) {\n    // Special case for remove changes that are supersets of one another\n    if (arrayStartsWith(myChanges, theirChanges)\n        && skipRemoveSuperset(their, myChanges, myChanges.length - theirChanges.length)) {\n      hunk.lines.push(... myChanges);\n      return;\n    } else if (arrayStartsWith(theirChanges, myChanges)\n        && skipRemoveSuperset(mine, theirChanges, theirChanges.length - myChanges.length)) {\n      hunk.lines.push(... theirChanges);\n      return;\n    }\n  } else if (arrayEqual(myChanges, theirChanges)) {\n    hunk.lines.push(... myChanges);\n    return;\n  }\n\n  conflict(hunk, myChanges, theirChanges);\n}\n\nfunction removal(hunk, mine, their, swap) {\n  let myChanges = collectChange(mine),\n      theirChanges = collectContext(their, myChanges);\n  if (theirChanges.merged) {\n    hunk.lines.push(... theirChanges.merged);\n  } else {\n    conflict(hunk, swap ? theirChanges : myChanges, swap ? myChanges : theirChanges);\n  }\n}\n\nfunction conflict(hunk, mine, their) {\n  hunk.conflict = true;\n  hunk.lines.push({\n    conflict: true,\n    mine: mine,\n    theirs: their\n  });\n}\n\nfunction insertLeading(hunk, insert, their) {\n  while (insert.offset < their.offset && insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n    insert.offset++;\n  }\n}\nfunction insertTrailing(hunk, insert) {\n  while (insert.index < insert.lines.length) {\n    let line = insert.lines[insert.index++];\n    hunk.lines.push(line);\n  }\n}\n\nfunction collectChange(state) {\n  let ret = [],\n      operation = state.lines[state.index][0];\n  while (state.index < state.lines.length) {\n    let line = state.lines[state.index];\n\n    // Group additions that are immediately after subtractions and treat them as one \"atomic\" modify change.\n    if (operation === '-' && line[0] === '+') {\n      operation = '+';\n    }\n\n    if (operation === line[0]) {\n      ret.push(line);\n      state.index++;\n    } else {\n      break;\n    }\n  }\n\n  return ret;\n}\nfunction collectContext(state, matchChanges) {\n  let changes = [],\n      merged = [],\n      matchIndex = 0,\n      contextChanges = false,\n      conflicted = false;\n  while (matchIndex < matchChanges.length\n        && state.index < state.lines.length) {\n    let change = state.lines[state.index],\n        match = matchChanges[matchIndex];\n\n    // Once we've hit our add, then we are done\n    if (match[0] === '+') {\n      break;\n    }\n\n    contextChanges = contextChanges || change[0] !== ' ';\n\n    merged.push(match);\n    matchIndex++;\n\n    // Consume any additions in the other block as a conflict to attempt\n    // to pull in the remaining context after this\n    if (change[0] === '+') {\n      conflicted = true;\n\n      while (change[0] === '+') {\n        changes.push(change);\n        change = state.lines[++state.index];\n      }\n    }\n\n    if (match.substr(1) === change.substr(1)) {\n      changes.push(change);\n      state.index++;\n    } else {\n      conflicted = true;\n    }\n  }\n\n  if ((matchChanges[matchIndex] || '')[0] === '+'\n      && contextChanges) {\n    conflicted = true;\n  }\n\n  if (conflicted) {\n    return changes;\n  }\n\n  while (matchIndex < matchChanges.length) {\n    merged.push(matchChanges[matchIndex++]);\n  }\n\n  return {\n    merged,\n    changes\n  };\n}\n\nfunction allRemoves(changes) {\n  return changes.reduce(function(prev, change) {\n    return prev && change[0] === '-';\n  }, true);\n}\nfunction skipRemoveSuperset(state, removeChanges, delta) {\n  for (let i = 0; i < delta; i++) {\n    let changeContent = removeChanges[removeChanges.length - delta + i].substr(1);\n    if (state.lines[state.index + i] !== ' ' + changeContent) {\n      return false;\n    }\n  }\n\n  state.index += delta;\n  return true;\n}\n\nfunction calcOldNewLineCount(lines) {\n  let oldLines = 0;\n  let newLines = 0;\n\n  lines.forEach(function(line) {\n    if (typeof line !== 'string') {\n      let myCount = calcOldNewLineCount(line.mine);\n      let theirCount = calcOldNewLineCount(line.theirs);\n\n      if (oldLines !== undefined) {\n        if (myCount.oldLines === theirCount.oldLines) {\n          oldLines += myCount.oldLines;\n        } else {\n          oldLines = undefined;\n        }\n      }\n\n      if (newLines !== undefined) {\n        if (myCount.newLines === theirCount.newLines) {\n          newLines += myCount.newLines;\n        } else {\n          newLines = undefined;\n        }\n      }\n    } else {\n      if (newLines !== undefined && (line[0] === '+' || line[0] === ' ')) {\n        newLines++;\n      }\n      if (oldLines !== undefined && (line[0] === '-' || line[0] === ' ')) {\n        oldLines++;\n      }\n    }\n  });\n\n  return {oldLines, newLines};\n}\n"]} + + +/***/ }), +/* 14 */ +/***/ (function(module, exports, __webpack_require__) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/structuredPatch = structuredPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createTwoFilesPatch = createTwoFilesPatch; + /*istanbul ignore start*/exports. /*istanbul ignore end*/createPatch = createPatch; + + var /*istanbul ignore start*/_line = __webpack_require__(5) /*istanbul ignore end*/; + + /*istanbul ignore start*/function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } } + + /*istanbul ignore end*/function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + if (!options) { + options = {}; + } + if (typeof options.context === 'undefined') { + options.context = 4; + } + + var diff = /*istanbul ignore start*/(0, _line.diffLines) /*istanbul ignore end*/(oldStr, newStr, options); + diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier + + function contextLines(lines) { + return lines.map(function (entry) { + return ' ' + entry; + }); + } + + var hunks = []; + var oldRangeStart = 0, + newRangeStart = 0, + curRange = [], + oldLine = 1, + newLine = 1; + + /*istanbul ignore start*/var _loop = function _loop( /*istanbul ignore end*/i) { + var current = diff[i], + lines = current.lines || current.value.replace(/\n$/, '').split('\n'); + current.lines = lines; + + if (current.added || current.removed) { + /*istanbul ignore start*/var _curRange; + + /*istanbul ignore end*/ // If we have previous context, start with that + if (!oldRangeStart) { + var prev = diff[i - 1]; + oldRangeStart = oldLine; + newRangeStart = newLine; + + if (prev) { + curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : []; + oldRangeStart -= curRange.length; + newRangeStart -= curRange.length; + } + } + + // Output our changes + /*istanbul ignore start*/(_curRange = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/lines.map(function (entry) { + return (current.added ? '+' : '-') + entry; + }))); + + // Track the updated file position + if (current.added) { + newLine += lines.length; + } else { + oldLine += lines.length; + } + } else { + // Identical context lines. Track line changes + if (oldRangeStart) { + // Close out any changes that have been output (or join overlapping) + if (lines.length <= options.context * 2 && i < diff.length - 2) { + /*istanbul ignore start*/var _curRange2; + + /*istanbul ignore end*/ // Overlapping + /*istanbul ignore start*/(_curRange2 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange2 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines))); + } else { + /*istanbul ignore start*/var _curRange3; + + /*istanbul ignore end*/ // end the range and output + var contextSize = Math.min(lines.length, options.context); + /*istanbul ignore start*/(_curRange3 = /*istanbul ignore end*/curRange).push. /*istanbul ignore start*/apply /*istanbul ignore end*/( /*istanbul ignore start*/_curRange3 /*istanbul ignore end*/, /*istanbul ignore start*/_toConsumableArray( /*istanbul ignore end*/contextLines(lines.slice(0, contextSize)))); + + var hunk = { + oldStart: oldRangeStart, + oldLines: oldLine - oldRangeStart + contextSize, + newStart: newRangeStart, + newLines: newLine - newRangeStart + contextSize, + lines: curRange + }; + if (i >= diff.length - 2 && lines.length <= options.context) { + // EOF is inside this hunk + var oldEOFNewline = /\n$/.test(oldStr); + var newEOFNewline = /\n$/.test(newStr); + if (lines.length == 0 && !oldEOFNewline) { + // special case: old has no eol and no trailing context; no-nl can end up before adds + curRange.splice(hunk.oldLines, 0, '\\ No newline at end of file'); + } else if (!oldEOFNewline || !newEOFNewline) { + curRange.push('\\ No newline at end of file'); + } + } + hunks.push(hunk); + + oldRangeStart = 0; + newRangeStart = 0; + curRange = []; + } + } + oldLine += lines.length; + newLine += lines.length; + } + }; + + for (var i = 0; i < diff.length; i++) { + /*istanbul ignore start*/_loop( /*istanbul ignore end*/i); + } + + return { + oldFileName: oldFileName, newFileName: newFileName, + oldHeader: oldHeader, newHeader: newHeader, + hunks: hunks + }; + } + + function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) { + var diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options); + + var ret = []; + if (oldFileName == newFileName) { + ret.push('Index: ' + oldFileName); + } + ret.push('==================================================================='); + ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\t' + diff.oldHeader)); + ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\t' + diff.newHeader)); + + for (var i = 0; i < diff.hunks.length; i++) { + var hunk = diff.hunks[i]; + ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines + ' +' + hunk.newStart + ',' + hunk.newLines + ' @@'); + ret.push.apply(ret, hunk.lines); + } + + return ret.join('\n') + '\n'; + } + + function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) { + return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options); + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/patch/create.js"],"names":["structuredPatch","createTwoFilesPatch","createPatch","oldFileName","newFileName","oldStr","newStr","oldHeader","newHeader","options","context","diff","push","value","lines","contextLines","map","entry","hunks","oldRangeStart","newRangeStart","curRange","oldLine","newLine","i","current","replace","split","added","removed","prev","slice","length","contextSize","Math","min","hunk","oldStart","oldLines","newStart","newLines","oldEOFNewline","test","newEOFNewline","splice","ret","apply","join","fileName"],"mappings":"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","file":"create.js","sourcesContent":["import {diffLines} from '../diff/line';\n\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  if (!options) {\n    options = {};\n  }\n  if (typeof options.context === 'undefined') {\n    options.context = 4;\n  }\n\n  const diff = diffLines(oldStr, newStr, options);\n  diff.push({value: '', lines: []});   // Append an empty value to make cleanup easier\n\n  function contextLines(lines) {\n    return lines.map(function(entry) { return ' ' + entry; });\n  }\n\n  let hunks = [];\n  let oldRangeStart = 0, newRangeStart = 0, curRange = [],\n      oldLine = 1, newLine = 1;\n  for (let i = 0; i < diff.length; i++) {\n    const current = diff[i],\n          lines = current.lines || current.value.replace(/\\n$/, '').split('\\n');\n    current.lines = lines;\n\n    if (current.added || current.removed) {\n      // If we have previous context, start with that\n      if (!oldRangeStart) {\n        const prev = diff[i - 1];\n        oldRangeStart = oldLine;\n        newRangeStart = newLine;\n\n        if (prev) {\n          curRange = options.context > 0 ? contextLines(prev.lines.slice(-options.context)) : [];\n          oldRangeStart -= curRange.length;\n          newRangeStart -= curRange.length;\n        }\n      }\n\n      // Output our changes\n      curRange.push(... lines.map(function(entry) {\n        return (current.added ? '+' : '-') + entry;\n      }));\n\n      // Track the updated file position\n      if (current.added) {\n        newLine += lines.length;\n      } else {\n        oldLine += lines.length;\n      }\n    } else {\n      // Identical context lines. Track line changes\n      if (oldRangeStart) {\n        // Close out any changes that have been output (or join overlapping)\n        if (lines.length <= options.context * 2 && i < diff.length - 2) {\n          // Overlapping\n          curRange.push(... contextLines(lines));\n        } else {\n          // end the range and output\n          let contextSize = Math.min(lines.length, options.context);\n          curRange.push(... contextLines(lines.slice(0, contextSize)));\n\n          let hunk = {\n            oldStart: oldRangeStart,\n            oldLines: (oldLine - oldRangeStart + contextSize),\n            newStart: newRangeStart,\n            newLines: (newLine - newRangeStart + contextSize),\n            lines: curRange\n          };\n          if (i >= diff.length - 2 && lines.length <= options.context) {\n            // EOF is inside this hunk\n            let oldEOFNewline = (/\\n$/.test(oldStr));\n            let newEOFNewline = (/\\n$/.test(newStr));\n            if (lines.length == 0 && !oldEOFNewline) {\n              // special case: old has no eol and no trailing context; no-nl can end up before adds\n              curRange.splice(hunk.oldLines, 0, '\\\\ No newline at end of file');\n            } else if (!oldEOFNewline || !newEOFNewline) {\n              curRange.push('\\\\ No newline at end of file');\n            }\n          }\n          hunks.push(hunk);\n\n          oldRangeStart = 0;\n          newRangeStart = 0;\n          curRange = [];\n        }\n      }\n      oldLine += lines.length;\n      newLine += lines.length;\n    }\n  }\n\n  return {\n    oldFileName: oldFileName, newFileName: newFileName,\n    oldHeader: oldHeader, newHeader: newHeader,\n    hunks: hunks\n  };\n}\n\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n  const diff = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);\n\n  const ret = [];\n  if (oldFileName == newFileName) {\n    ret.push('Index: ' + oldFileName);\n  }\n  ret.push('===================================================================');\n  ret.push('--- ' + diff.oldFileName + (typeof diff.oldHeader === 'undefined' ? '' : '\\t' + diff.oldHeader));\n  ret.push('+++ ' + diff.newFileName + (typeof diff.newHeader === 'undefined' ? '' : '\\t' + diff.newHeader));\n\n  for (let i = 0; i < diff.hunks.length; i++) {\n    const hunk = diff.hunks[i];\n    ret.push(\n      '@@ -' + hunk.oldStart + ',' + hunk.oldLines\n      + ' +' + hunk.newStart + ',' + hunk.newLines\n      + ' @@'\n    );\n    ret.push.apply(ret, hunk.lines);\n  }\n\n  return ret.join('\\n') + '\\n';\n}\n\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n  return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n"]} + + +/***/ }), +/* 15 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + exports. /*istanbul ignore end*/arrayEqual = arrayEqual; + /*istanbul ignore start*/exports. /*istanbul ignore end*/arrayStartsWith = arrayStartsWith; + function arrayEqual(a, b) { + if (a.length !== b.length) { + return false; + } + + return arrayStartsWith(a, b); + } + + function arrayStartsWith(array, start) { + if (start.length > array.length) { + return false; + } + + for (var i = 0; i < start.length; i++) { + if (start[i] !== array[i]) { + return false; + } + } + + return true; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91dGlsL2FycmF5LmpzIl0sIm5hbWVzIjpbImFycmF5RXF1YWwiLCJhcnJheVN0YXJ0c1dpdGgiLCJhIiwiYiIsImxlbmd0aCIsImFycmF5Iiwic3RhcnQiLCJpIl0sIm1hcHBpbmdzIjoiOzs7Z0NBQWdCQSxVLEdBQUFBLFU7eURBUUFDLGUsR0FBQUEsZTtBQVJULFNBQVNELFVBQVQsQ0FBb0JFLENBQXBCLEVBQXVCQyxDQUF2QixFQUEwQjtBQUMvQixNQUFJRCxFQUFFRSxNQUFGLEtBQWFELEVBQUVDLE1BQW5CLEVBQTJCO0FBQ3pCLFdBQU8sS0FBUDtBQUNEOztBQUVELFNBQU9ILGdCQUFnQkMsQ0FBaEIsRUFBbUJDLENBQW5CLENBQVA7QUFDRDs7QUFFTSxTQUFTRixlQUFULENBQXlCSSxLQUF6QixFQUFnQ0MsS0FBaEMsRUFBdUM7QUFDNUMsTUFBSUEsTUFBTUYsTUFBTixHQUFlQyxNQUFNRCxNQUF6QixFQUFpQztBQUMvQixXQUFPLEtBQVA7QUFDRDs7QUFFRCxPQUFLLElBQUlHLElBQUksQ0FBYixFQUFnQkEsSUFBSUQsTUFBTUYsTUFBMUIsRUFBa0NHLEdBQWxDLEVBQXVDO0FBQ3JDLFFBQUlELE1BQU1DLENBQU4sTUFBYUYsTUFBTUUsQ0FBTixDQUFqQixFQUEyQjtBQUN6QixhQUFPLEtBQVA7QUFDRDtBQUNGOztBQUVELFNBQU8sSUFBUDtBQUNEIiwiZmlsZSI6ImFycmF5LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGFycmF5RXF1YWwoYSwgYikge1xuICBpZiAoYS5sZW5ndGggIT09IGIubGVuZ3RoKSB7XG4gICAgcmV0dXJuIGZhbHNlO1xuICB9XG5cbiAgcmV0dXJuIGFycmF5U3RhcnRzV2l0aChhLCBiKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGFycmF5U3RhcnRzV2l0aChhcnJheSwgc3RhcnQpIHtcbiAgaWYgKHN0YXJ0Lmxlbmd0aCA+IGFycmF5Lmxlbmd0aCkge1xuICAgIHJldHVybiBmYWxzZTtcbiAgfVxuXG4gIGZvciAobGV0IGkgPSAwOyBpIDwgc3RhcnQubGVuZ3RoOyBpKyspIHtcbiAgICBpZiAoc3RhcnRbaV0gIT09IGFycmF5W2ldKSB7XG4gICAgICByZXR1cm4gZmFsc2U7XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIHRydWU7XG59XG4iXX0= + + +/***/ }), +/* 16 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/"use strict"; + + exports.__esModule = true; + exports. /*istanbul ignore end*/convertChangesToDMP = convertChangesToDMP; + // See: http://code.google.com/p/google-diff-match-patch/wiki/API + function convertChangesToDMP(changes) { + var ret = [], + change = /*istanbul ignore start*/void 0 /*istanbul ignore end*/, + operation = /*istanbul ignore start*/void 0 /*istanbul ignore end*/; + for (var i = 0; i < changes.length; i++) { + change = changes[i]; + if (change.added) { + operation = 1; + } else if (change.removed) { + operation = -1; + } else { + operation = 0; + } + + ret.push([operation, change.value]); + } + return ret; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb252ZXJ0L2RtcC5qcyJdLCJuYW1lcyI6WyJjb252ZXJ0Q2hhbmdlc1RvRE1QIiwiY2hhbmdlcyIsInJldCIsImNoYW5nZSIsIm9wZXJhdGlvbiIsImkiLCJsZW5ndGgiLCJhZGRlZCIsInJlbW92ZWQiLCJwdXNoIiwidmFsdWUiXSwibWFwcGluZ3MiOiI7OztnQ0FDZ0JBLG1CLEdBQUFBLG1CO0FBRGhCO0FBQ08sU0FBU0EsbUJBQVQsQ0FBNkJDLE9BQTdCLEVBQXNDO0FBQzNDLE1BQUlDLE1BQU0sRUFBVjtBQUFBLE1BQ0lDLHdDQURKO0FBQUEsTUFFSUMsMkNBRko7QUFHQSxPQUFLLElBQUlDLElBQUksQ0FBYixFQUFnQkEsSUFBSUosUUFBUUssTUFBNUIsRUFBb0NELEdBQXBDLEVBQXlDO0FBQ3ZDRixhQUFTRixRQUFRSSxDQUFSLENBQVQ7QUFDQSxRQUFJRixPQUFPSSxLQUFYLEVBQWtCO0FBQ2hCSCxrQkFBWSxDQUFaO0FBQ0QsS0FGRCxNQUVPLElBQUlELE9BQU9LLE9BQVgsRUFBb0I7QUFDekJKLGtCQUFZLENBQUMsQ0FBYjtBQUNELEtBRk0sTUFFQTtBQUNMQSxrQkFBWSxDQUFaO0FBQ0Q7O0FBRURGLFFBQUlPLElBQUosQ0FBUyxDQUFDTCxTQUFELEVBQVlELE9BQU9PLEtBQW5CLENBQVQ7QUFDRDtBQUNELFNBQU9SLEdBQVA7QUFDRCIsImZpbGUiOiJkbXAuanMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBTZWU6IGh0dHA6Ly9jb2RlLmdvb2dsZS5jb20vcC9nb29nbGUtZGlmZi1tYXRjaC1wYXRjaC93aWtpL0FQSVxuZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRDaGFuZ2VzVG9ETVAoY2hhbmdlcykge1xuICBsZXQgcmV0ID0gW10sXG4gICAgICBjaGFuZ2UsXG4gICAgICBvcGVyYXRpb247XG4gIGZvciAobGV0IGkgPSAwOyBpIDwgY2hhbmdlcy5sZW5ndGg7IGkrKykge1xuICAgIGNoYW5nZSA9IGNoYW5nZXNbaV07XG4gICAgaWYgKGNoYW5nZS5hZGRlZCkge1xuICAgICAgb3BlcmF0aW9uID0gMTtcbiAgICB9IGVsc2UgaWYgKGNoYW5nZS5yZW1vdmVkKSB7XG4gICAgICBvcGVyYXRpb24gPSAtMTtcbiAgICB9IGVsc2Uge1xuICAgICAgb3BlcmF0aW9uID0gMDtcbiAgICB9XG5cbiAgICByZXQucHVzaChbb3BlcmF0aW9uLCBjaGFuZ2UudmFsdWVdKTtcbiAgfVxuICByZXR1cm4gcmV0O1xufVxuIl19 + + +/***/ }), +/* 17 */ +/***/ (function(module, exports) { + + /*istanbul ignore start*/'use strict'; + + exports.__esModule = true; + exports. /*istanbul ignore end*/convertChangesToXML = convertChangesToXML; + function convertChangesToXML(changes) { + var ret = []; + for (var i = 0; i < changes.length; i++) { + var change = changes[i]; + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + + ret.push(escapeHTML(change.value)); + + if (change.added) { + ret.push(''); + } else if (change.removed) { + ret.push(''); + } + } + return ret.join(''); + } + + function escapeHTML(s) { + var n = s; + n = n.replace(/&/g, '&'); + n = n.replace(//g, '>'); + n = n.replace(/"/g, '"'); + + return n; + } + //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb252ZXJ0L3htbC5qcyJdLCJuYW1lcyI6WyJjb252ZXJ0Q2hhbmdlc1RvWE1MIiwiY2hhbmdlcyIsInJldCIsImkiLCJsZW5ndGgiLCJjaGFuZ2UiLCJhZGRlZCIsInB1c2giLCJyZW1vdmVkIiwiZXNjYXBlSFRNTCIsInZhbHVlIiwiam9pbiIsInMiLCJuIiwicmVwbGFjZSJdLCJtYXBwaW5ncyI6Ijs7O2dDQUFnQkEsbUIsR0FBQUEsbUI7QUFBVCxTQUFTQSxtQkFBVCxDQUE2QkMsT0FBN0IsRUFBc0M7QUFDM0MsTUFBSUMsTUFBTSxFQUFWO0FBQ0EsT0FBSyxJQUFJQyxJQUFJLENBQWIsRUFBZ0JBLElBQUlGLFFBQVFHLE1BQTVCLEVBQW9DRCxHQUFwQyxFQUF5QztBQUN2QyxRQUFJRSxTQUFTSixRQUFRRSxDQUFSLENBQWI7QUFDQSxRQUFJRSxPQUFPQyxLQUFYLEVBQWtCO0FBQ2hCSixVQUFJSyxJQUFKLENBQVMsT0FBVDtBQUNELEtBRkQsTUFFTyxJQUFJRixPQUFPRyxPQUFYLEVBQW9CO0FBQ3pCTixVQUFJSyxJQUFKLENBQVMsT0FBVDtBQUNEOztBQUVETCxRQUFJSyxJQUFKLENBQVNFLFdBQVdKLE9BQU9LLEtBQWxCLENBQVQ7O0FBRUEsUUFBSUwsT0FBT0MsS0FBWCxFQUFrQjtBQUNoQkosVUFBSUssSUFBSixDQUFTLFFBQVQ7QUFDRCxLQUZELE1BRU8sSUFBSUYsT0FBT0csT0FBWCxFQUFvQjtBQUN6Qk4sVUFBSUssSUFBSixDQUFTLFFBQVQ7QUFDRDtBQUNGO0FBQ0QsU0FBT0wsSUFBSVMsSUFBSixDQUFTLEVBQVQsQ0FBUDtBQUNEOztBQUVELFNBQVNGLFVBQVQsQ0FBb0JHLENBQXBCLEVBQXVCO0FBQ3JCLE1BQUlDLElBQUlELENBQVI7QUFDQUMsTUFBSUEsRUFBRUMsT0FBRixDQUFVLElBQVYsRUFBZ0IsT0FBaEIsQ0FBSjtBQUNBRCxNQUFJQSxFQUFFQyxPQUFGLENBQVUsSUFBVixFQUFnQixNQUFoQixDQUFKO0FBQ0FELE1BQUlBLEVBQUVDLE9BQUYsQ0FBVSxJQUFWLEVBQWdCLE1BQWhCLENBQUo7QUFDQUQsTUFBSUEsRUFBRUMsT0FBRixDQUFVLElBQVYsRUFBZ0IsUUFBaEIsQ0FBSjs7QUFFQSxTQUFPRCxDQUFQO0FBQ0QiLCJmaWxlIjoieG1sLmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGNvbnZlcnRDaGFuZ2VzVG9YTUwoY2hhbmdlcykge1xuICBsZXQgcmV0ID0gW107XG4gIGZvciAobGV0IGkgPSAwOyBpIDwgY2hhbmdlcy5sZW5ndGg7IGkrKykge1xuICAgIGxldCBjaGFuZ2UgPSBjaGFuZ2VzW2ldO1xuICAgIGlmIChjaGFuZ2UuYWRkZWQpIHtcbiAgICAgIHJldC5wdXNoKCc8aW5zPicpO1xuICAgIH0gZWxzZSBpZiAoY2hhbmdlLnJlbW92ZWQpIHtcbiAgICAgIHJldC5wdXNoKCc8ZGVsPicpO1xuICAgIH1cblxuICAgIHJldC5wdXNoKGVzY2FwZUhUTUwoY2hhbmdlLnZhbHVlKSk7XG5cbiAgICBpZiAoY2hhbmdlLmFkZGVkKSB7XG4gICAgICByZXQucHVzaCgnPC9pbnM+Jyk7XG4gICAgfSBlbHNlIGlmIChjaGFuZ2UucmVtb3ZlZCkge1xuICAgICAgcmV0LnB1c2goJzwvZGVsPicpO1xuICAgIH1cbiAgfVxuICByZXR1cm4gcmV0LmpvaW4oJycpO1xufVxuXG5mdW5jdGlvbiBlc2NhcGVIVE1MKHMpIHtcbiAgbGV0IG4gPSBzO1xuICBuID0gbi5yZXBsYWNlKC8mL2csICcmYW1wOycpO1xuICBuID0gbi5yZXBsYWNlKC88L2csICcmbHQ7Jyk7XG4gIG4gPSBuLnJlcGxhY2UoLz4vZywgJyZndDsnKTtcbiAgbiA9IG4ucmVwbGFjZSgvXCIvZywgJyZxdW90OycpO1xuXG4gIHJldHVybiBuO1xufVxuIl19 + + +/***/ }) +/******/ ]) +}); +; + /***/ }) /******/ ]); \ No newline at end of file diff --git a/compare/src/actions/index.js b/compare/src/actions/index.js index 969774336..fa5aef945 100644 --- a/compare/src/actions/index.js +++ b/compare/src/actions/index.js @@ -61,6 +61,13 @@ export const showScrubberDiffImage = value => { }; }; +export const showScrubberDivergedImage = value => { + return { + type: 'SHOW_SCRUBBER_DIVERGED_IMAGE', + value + }; +}; + export const showScrubber = value => { return { type: 'SHOW_SCRUBBER', diff --git a/compare/src/components/atoms/ButtonFilter.js b/compare/src/components/atoms/ButtonFilter.js index 0a245acd9..5ea47af88 100644 --- a/compare/src/components/atoms/ButtonFilter.js +++ b/compare/src/components/atoms/ButtonFilter.js @@ -37,7 +37,7 @@ const Button = styled.button` `; export default class ButtonFilter extends React.Component { - render() { + render () { let { count, label, status } = this.props; return ( diff --git a/compare/src/components/atoms/ButtonSettings.js b/compare/src/components/atoms/ButtonSettings.js index 88806e8bd..c85986c42 100644 --- a/compare/src/components/atoms/ButtonSettings.js +++ b/compare/src/components/atoms/ButtonSettings.js @@ -48,7 +48,7 @@ const Button = styled.button` `; export default class ButtonSettings extends React.Component { - render() { + render () { let isActive = this.props.active ? 'active' : ''; return ( diff --git a/compare/src/components/atoms/DiffDetails.js b/compare/src/components/atoms/DiffDetails.js index d5ed4be75..4b3e33ee8 100644 --- a/compare/src/components/atoms/DiffDetails.js +++ b/compare/src/components/atoms/DiffDetails.js @@ -17,7 +17,7 @@ const Value = styled.span` `; export default class DiffDetails extends React.Component { - render() { + render () { let { diff, suppress } = this.props; if (!diff || suppress) { return null; diff --git a/compare/src/components/atoms/ErrorMessages.js b/compare/src/components/atoms/ErrorMessages.js index 9f2df68ed..3fea4a1ec 100644 --- a/compare/src/components/atoms/ErrorMessages.js +++ b/compare/src/components/atoms/ErrorMessages.js @@ -5,7 +5,7 @@ import { colors, fonts } from '../../styles'; const DetailsPanel = styled.div` background: transparent; - display: ${props => (!!props.display ? 'block' : 'none')}; + display: ${props => (props.display ? 'block' : 'none')}; padding: 10px; font-family: ${fonts.latoRegular}; color: ${colors.secondaryText}; @@ -17,16 +17,16 @@ const ErrorMsg = styled.p` background: rgb(251, 234, 234); padding: 2ex; color: brown; - display: ${props => (!!props.display ? 'block' : 'none')}; + display: ${props => (props.display ? 'block' : 'none')}; `; class ErrorMessages extends React.Component { - constructor(props) { + constructor (props) { super(props); this.state = {}; } - render() { + render () { const backstopError = this.props.info.error; const engineError = this.props.info.engineErrorMsg; const display = !!engineError || !!backstopError; diff --git a/compare/src/components/atoms/IdContainer.js b/compare/src/components/atoms/IdContainer.js index acc51d157..31c331093 100644 --- a/compare/src/components/atoms/IdContainer.js +++ b/compare/src/components/atoms/IdContainer.js @@ -30,7 +30,7 @@ const IdTitle = styled.h3` `; class IdConfig extends React.Component { - render() { + render () { return {this.props.idConfig}; } } diff --git a/compare/src/components/atoms/ImagePreview.js b/compare/src/components/atoms/ImagePreview.js index 2275ff105..14fb31fdc 100644 --- a/compare/src/components/atoms/ImagePreview.js +++ b/compare/src/components/atoms/ImagePreview.js @@ -44,16 +44,16 @@ const visibilitySensorProps = { }; class ImagePreview extends React.Component { - constructor(props) { + constructor (props) { super(props); this.state = { - isVisible: false, + isVisible: false }; this.onLoadError = this.onLoadError.bind(this); this.onChange = this.onChange.bind(this); } - onChange(isVisible) { + onChange (isVisible) { if (isVisible && !this.state.isVisible) { console.log('setting state to visible'); this.setState({ @@ -62,13 +62,13 @@ class ImagePreview extends React.Component { } } - onLoadError() { + onLoadError () { this.setState({ imgLoadError: true }); } - render() { + render () { let { hidden, settings, label, src } = this.props; if (!src || src === '../..' || this.state.imgLoadError) { src = BASE64_PNG_STUB; @@ -81,7 +81,9 @@ class ImagePreview extends React.Component { ); } - return ; + return ( + + ); } } diff --git a/compare/src/components/atoms/ImageScrubber.js b/compare/src/components/atoms/ImageScrubber.js index 0402ab9a9..efc6cebeb 100644 --- a/compare/src/components/atoms/ImageScrubber.js +++ b/compare/src/components/atoms/ImageScrubber.js @@ -3,6 +3,7 @@ import { connect } from 'react-redux'; import styled from 'styled-components'; import TwentyTwenty from 'backstop-twentytwenty'; import { colors, fonts, shadows } from '../../styles'; +import diverged from 'diverged'; const BASE64_PNG_STUB = 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7'; @@ -63,7 +64,7 @@ const SliderBar = styled.div` `; export default class ImageScrubber extends React.Component { - constructor(props) { + constructor (props) { super(props); this.state = { dontUseScrubberView: false @@ -72,61 +73,102 @@ export default class ImageScrubber extends React.Component { this.handleLoadingError = this.handleLoadingError.bind(this); } - handleLoadingError() { + handleLoadingError () { this.setState({ dontUseScrubberView: true }); } - render() { + render () { + console.log('ImageScrubber PROPS>>>', this.props); const { + scrubberModalMode, + testImageType, position, refImage, testImage, diffImage, + divergedImage, showButtons, showScrubberTestImage, showScrubberRefImage, showScrubberDiffImage, + showScrubberDivergedImage, showScrubber } = this.props; - const dontUseScrubberView = this.state.dontUseScrubberView || !showButtons; + const scrubberTestImageSlug = this.props[testImageType]; + + function getDiverged (arg) { + if (divergedImage) { + showScrubberDivergedImage(divergedImage); + return; + } + + const refImg = document.images.scrubberRefImage; + const testImg = document.images.isolatedTestImage; + + const h = refImg.height; + const w = refImg.width; + const refCtx = imageToCanvasContext(refImg); + const testCtx = imageToCanvasContext(testImg); + + console.log('starting diverged>>', new Date()); + const divergedImgData = diverged( + getImgDataDataFromContext(refCtx), + getImgDataDataFromContext(testCtx), + h, + w + ); + + let clampedImgData = getEmptyImgData(h, w); + for (var i = divergedImgData.length - 1; i >= 0; i--) { + clampedImgData.data[i] = divergedImgData[i]; + } + var lcsDiffResult = imageToCanvasContext(null, w, h); + lcsDiffResult.putImageData(clampedImgData, 0, 0); + + const divergedImageResult = lcsDiffResult.canvas.toDataURL('image/png'); + showScrubberDivergedImage(divergedImageResult); + } + const dontUseScrubberView = this.state.dontUseScrubberView || !showButtons; return ( {showButtons && (
{ - showScrubberRefImage(); - }} + selected={scrubberModalMode === 'SHOW_SCRUBBER_REF_IMAGE'} + onClick={showScrubberRefImage} > REFERENCE + { - showScrubberTestImage(); - }} + selected={scrubberModalMode === 'SHOW_SCRUBBER_TEST_IMAGE'} + onClick={showScrubberTestImage} > TEST + { - showScrubberDiffImage(); - }} + selected={scrubberModalMode === 'SHOW_SCRUBBER_DIFF_IMAGE'} + onClick={showScrubberDiffImage} > DIFF + + {/* + DIVERGED + */} + { - showScrubber(); - }} + selected={scrubberModalMode === 'SCRUB'} + onClick={showScrubber} > SCRUBBER @@ -134,6 +176,7 @@ export default class ImageScrubber extends React.Component { )} - +
@@ -175,11 +223,30 @@ export default class ImageScrubber extends React.Component { } } -// const mapStateToProps = state => { -// console.log('map state>>>',state) -// return { -// test_: state -// }; -// }; +/** + * ========= DIVERGED HELPERS ======== + */ +function getImgDataDataFromContext (context) { + return context.getImageData(0, 0, context.canvas.width, context.canvas.height) + .data; +} + +function getEmptyImgData (h, w) { + var o = imageToCanvasContext(null, h, w); + return o.createImageData(w, h); +} -// const ImageScrubberContainer = connect(mapStateToProps)(ImageScrubber); +function imageToCanvasContext (_img, w, h) { + let img = _img; + if (!_img) { + img = { width: w, height: h }; + } + const canvas = document.createElement('canvas'); + canvas.width = img.width; + canvas.height = img.height; + const context = canvas.getContext('2d'); + if (_img) { + context.drawImage(img, 0, 0); + } + return context; +} diff --git a/compare/src/components/atoms/InputTextSearch.js b/compare/src/components/atoms/InputTextSearch.js index 0ba141e7f..49e90fc77 100644 --- a/compare/src/components/atoms/InputTextSearch.js +++ b/compare/src/components/atoms/InputTextSearch.js @@ -36,7 +36,7 @@ const Input = styled.input` `; export default class ButtonFilter extends React.Component { - render() { + render () { return ( diff --git a/compare/src/components/atoms/NavButtons.js b/compare/src/components/atoms/NavButtons.js index 28c60f1f3..ca31782fe 100644 --- a/compare/src/components/atoms/NavButtons.js +++ b/compare/src/components/atoms/NavButtons.js @@ -35,24 +35,24 @@ const ButtonNav = styled.div` `; export default class NavButtons extends React.Component { - nextTest() { + nextTest () { let dest = `#test${this.props.currentId + 1}`; this.jumpTo(dest); } - prevTest() { + prevTest () { let dest = `#test${this.props.currentId - 1}`; this.jumpTo(dest); } - jumpTo(dest) { + jumpTo (dest) { jump(dest, { duration: 0, offset: -100 }); } - render() { + render () { let { currentId, lastId } = this.props; return ( diff --git a/compare/src/components/atoms/SettingOption.js b/compare/src/components/atoms/SettingOption.js index 11de04263..f2c183cf5 100644 --- a/compare/src/components/atoms/SettingOption.js +++ b/compare/src/components/atoms/SettingOption.js @@ -21,7 +21,7 @@ const WrapperOption = styled.div` `; export default class SettingOption extends React.Component { - render() { + render () { let { label, value, onToggle } = this.props; return ( diff --git a/compare/src/components/atoms/SuiteName.js b/compare/src/components/atoms/SuiteName.js index 4f27ba0bd..dd0fa9f93 100644 --- a/compare/src/components/atoms/SuiteName.js +++ b/compare/src/components/atoms/SuiteName.js @@ -13,7 +13,7 @@ const SuiteNameTitle = styled.h1` `; class SuiteName extends React.Component { - render() { + render () { return {this.props.suiteName} Report; } } diff --git a/compare/src/components/atoms/TextDetails.js b/compare/src/components/atoms/TextDetails.js index f425e09da..b6b623a5c 100644 --- a/compare/src/components/atoms/TextDetails.js +++ b/compare/src/components/atoms/TextDetails.js @@ -39,7 +39,7 @@ const DetailsPanel = styled.div` `; class TextDetails extends React.Component { - constructor(props) { + constructor (props) { super(props); this.state = { @@ -50,7 +50,7 @@ class TextDetails extends React.Component { this.hidePanel = this.hidePanel.bind(this); } - showPanel() { + showPanel () { const { settings } = this.props; if (!settings.textInfo) { this.setState({ @@ -59,13 +59,13 @@ class TextDetails extends React.Component { } } - hidePanel() { + hidePanel () { this.setState({ showPanel: false }); } - render() { + render () { const { label, fileName, diff --git a/compare/src/components/atoms/UrlDetails.js b/compare/src/components/atoms/UrlDetails.js index db96891a5..002e2e9db 100644 --- a/compare/src/components/atoms/UrlDetails.js +++ b/compare/src/components/atoms/UrlDetails.js @@ -24,7 +24,7 @@ const Link = styled.a` `; export default class DiffDetails extends React.Component { - render() { + render () { const { url, referenceUrl } = this.props; return ( diff --git a/compare/src/components/ecosystems/Header.js b/compare/src/components/ecosystems/Header.js index 5237d6897..7d3a3387c 100644 --- a/compare/src/components/ecosystems/Header.js +++ b/compare/src/components/ecosystems/Header.js @@ -17,7 +17,7 @@ const HeaderWrapper = styled.section` `; export default class Header extends React.Component { - render() { + render () { return ( diff --git a/compare/src/components/ecosystems/List.js b/compare/src/components/ecosystems/List.js index 7a557e016..c099609f8 100644 --- a/compare/src/components/ecosystems/List.js +++ b/compare/src/components/ecosystems/List.js @@ -13,7 +13,7 @@ const ListWrapper = styled.section` `; class List extends React.Component { - render() { + render () { let { tests, settings } = this.props; let onlyText = !settings.refImage && !settings.testImage && !settings.diffImage; diff --git a/compare/src/components/ecosystems/ScrubberModal.js b/compare/src/components/ecosystems/ScrubberModal.js index 35c265c4e..d26ab5378 100644 --- a/compare/src/components/ecosystems/ScrubberModal.js +++ b/compare/src/components/ecosystems/ScrubberModal.js @@ -7,6 +7,7 @@ import { showScrubberTestImage, showScrubberRefImage, showScrubberDiffImage, + showScrubberDivergedImage, showScrubber } from '../../actions'; @@ -64,22 +65,30 @@ const customStyles = { }; class ScrubberModal extends React.Component { - constructor(props) { + constructor (props) { super(props); } - render() { + render () { const { reference: refImage, test: testImage, - diffImage + diffImage, + divergedImage } = this.props.scrubber.test; - const { visible, mode, position } = this.props.scrubber; + const { + visible, + mode, + position, + testImageType, + scrubberModalMode + } = this.props.scrubber; const { closeModal, showScrubberTestImage, showScrubberRefImage, showScrubberDiffImage, + showScrubberDivergedImage, showScrubber } = this.props; @@ -97,14 +106,18 @@ class ScrubberModal extends React.Component { 0} showScrubberTestImage={showScrubberTestImage} showScrubberRefImage={showScrubberRefImage} showScrubberDiffImage={showScrubberDiffImage} + showScrubberDivergedImage={showScrubberDivergedImage} showScrubber={showScrubber} /> @@ -133,6 +146,9 @@ const mapDispatchToProps = dispatch => { showScrubberDiffImage: val => { dispatch(showScrubberDiffImage(val)); }, + showScrubberDivergedImage: val => { + dispatch(showScrubberDivergedImage(val)); + }, showScrubber: val => { dispatch(showScrubber(val)); } diff --git a/compare/src/components/molecules/FiltersSwitch.js b/compare/src/components/molecules/FiltersSwitch.js index 2a2640fa9..4ab7b94f0 100644 --- a/compare/src/components/molecules/FiltersSwitch.js +++ b/compare/src/components/molecules/FiltersSwitch.js @@ -13,7 +13,7 @@ const ButtonsWrapper = styled.div` height: 100%; `; -function ButtonsFilter(props) { +function ButtonsFilter (props) { const availableStatus = props.availableStatus; const ListButton = availableStatus.map(status => ( @@ -34,11 +34,11 @@ function ButtonsFilter(props) { } class FiltersSwitch extends React.Component { - constructor(props) { + constructor (props) { super(props); } - render() { + render () { let tests = this.props.tests; let availableStatus = this.props.availableStatus; diff --git a/compare/src/components/molecules/ScrubberButton.js b/compare/src/components/molecules/ScrubberButton.js index c7e6ac132..8b9900a1b 100644 --- a/compare/src/components/molecules/ScrubberButton.js +++ b/compare/src/components/molecules/ScrubberButton.js @@ -31,23 +31,23 @@ const ButtonSD = styled.button` &:hover { cursor: pointer; } - + @media print { display: none; } `; class ScrubberButton extends React.Component { - constructor(props) { + constructor (props) { super(props); } - onClick() { + onClick () { let { openModal } = this.props; openModal(this.props.info); } - render() { + render () { return ( 0) { @@ -27,7 +27,7 @@ class TextSearch extends React.Component { } } - render() { + render () { return ( diff --git a/compare/src/components/organisms/TestCard.js b/compare/src/components/organisms/TestCard.js index 59e237ee4..3a0a18d13 100644 --- a/compare/src/components/organisms/TestCard.js +++ b/compare/src/components/organisms/TestCard.js @@ -38,7 +38,7 @@ const CardWrapper = styled.div` `; export default class TestCard extends React.Component { - render() { + render () { let { pair: info, status } = this.props.test; let onlyText = this.props.onlyText; @@ -48,7 +48,6 @@ export default class TestCard extends React.Component { )} - diff --git a/compare/src/components/organisms/Toolbar.js b/compare/src/components/organisms/Toolbar.js index 506d70e39..3a36a143f 100644 --- a/compare/src/components/organisms/Toolbar.js +++ b/compare/src/components/organisms/Toolbar.js @@ -14,14 +14,14 @@ const ToolbarWrapper = styled.section` height: 70px; display: flex; box-sizing: border-box; - + @media print { display: none; } `; export default class Toolbar extends React.Component { - render() { + render () { return ( diff --git a/compare/src/components/organisms/Topbar.js b/compare/src/components/organisms/Topbar.js index 8cde1961d..53aababab 100644 --- a/compare/src/components/organisms/Topbar.js +++ b/compare/src/components/organisms/Topbar.js @@ -26,7 +26,7 @@ const Separator = styled.div` `; export default class Topbar extends React.Component { - render() { + render () { return ( diff --git a/compare/src/reducers/scrubber.js b/compare/src/reducers/scrubber.js index f3f6159bf..6e5602af4 100644 --- a/compare/src/reducers/scrubber.js +++ b/compare/src/reducers/scrubber.js @@ -1,13 +1,26 @@ function getPosFromImgId (imgId) { switch (imgId) { case 'refImage': - return 100; + return 105; // just passed the right border case 'testImage': - return 0; + return -1; // just passed the left border case 'diffImage': - return -1; + return -1; // just passed the left border default: - return 50; + return 50; // in the middle + } +} + +function getModeFromImgId (imgId) { + switch (imgId) { + case 'refImage': + return 'SHOW_SCRUBBER_REF_IMAGE'; + case 'testImage': + return 'SHOW_SCRUBBER_TEST_IMAGE'; + case 'diffImage': + return 'SHOW_SCRUBBER_DIFF_IMAGE'; + default: + return 'SCRUB'; } } @@ -19,10 +32,17 @@ const scrubber = (state = {}, action) => { targetImgId = action.value.targetImg.id; } catch (err) {} + let scrubberModalMode = ''; + try { + scrubberModalMode = action.value.targetImg.id; + } catch (err) {} + return Object.assign({}, state, { position: getPosFromImgId(targetImgId), visible: true, - test: action.value + test: action.value, + testImageType: targetImgId, + scrubberModalMode: getModeFromImgId(targetImgId) }); case 'CLOSE_SCRUBBER_MODAL': @@ -33,22 +53,36 @@ const scrubber = (state = {}, action) => { case 'SHOW_SCRUBBER_TEST_IMAGE': return Object.assign({}, state, { - position: getPosFromImgId('testImage') + position: getPosFromImgId('testImage'), + scrubberModalMode: action.type, + testImageType: 'testImage' }); case 'SHOW_SCRUBBER_REF_IMAGE': return Object.assign({}, state, { - position: getPosFromImgId('refImage') + position: getPosFromImgId('refImage'), + scrubberModalMode: action.type }); case 'SHOW_SCRUBBER_DIFF_IMAGE': return Object.assign({}, state, { - position: getPosFromImgId('diffImage') + position: getPosFromImgId('diffImage'), + scrubberModalMode: action.type, + testImageType: 'diffImage' + }); + + case 'SHOW_SCRUBBER_DIVERGED_IMAGE': + return Object.assign({}, state, { + position: getPosFromImgId('diffImage'), + scrubberModalMode: action.type, + testImageType: 'divergedImage', + test: Object.assign({}, state.test, { divergedImage: action.value }) }); case 'SHOW_SCRUBBER': return Object.assign({}, state, { - position: getPosFromImgId() + position: getPosFromImgId(), + scrubberModalMode: 'SCRUB' }); default: diff --git a/core/command/index.js b/core/command/index.js index 0f59e5224..9e075ce66 100644 --- a/core/command/index.js +++ b/core/command/index.js @@ -12,7 +12,8 @@ var logger = require('../util/logger')('COMMAND'); /* Each and every command defined, including commands used in before/after */ var commandNames = [ - 'genConfig', + 'init', + 'remote', 'openReport', 'reference', 'report', @@ -22,7 +23,8 @@ var commandNames = [ /* Commands that are only exposed to higher levels */ var exposedCommandNames = [ - 'genConfig', + 'init', + 'remote', 'reference', 'test', 'openReport', diff --git a/core/command/genConfig.js b/core/command/init.js similarity index 92% rename from core/command/genConfig.js rename to core/command/init.js index f277886e6..9b695f42b 100644 --- a/core/command/genConfig.js +++ b/core/command/init.js @@ -1,13 +1,12 @@ var fs = require('../util/fs'); -var logger = require('../util/logger')('genConfig'); +var logger = require('../util/logger')('init'); /** * Copies a boilerplate config file to the current config file location. */ module.exports = { - execute: function genConfig (config) { + execute: function init (config) { var promises = []; - if (config.engine_scripts) { logger.log("Copying '" + config.engine_scripts_default + "' to '" + config.engine_scripts + "'"); promises.push(fs.copy(config.engine_scripts_default, config.engine_scripts)); diff --git a/core/command/openReport.js b/core/command/openReport.js index e6ea33cd7..8a0b6e558 100644 --- a/core/command/openReport.js +++ b/core/command/openReport.js @@ -1,17 +1,31 @@ -var open = require('opn'); -var logger = require('../util/logger')('openReport'); -var path = require('path'); +const open = require('opn'); +const logger = require('../util/logger')('openReport'); +const path = require('path'); +const http = require('http'); +const BACKSTOP_REPORT_SIGNATURE_RE = /BackstopJS Report/i; module.exports = { execute: function (config) { - function toAbsolute (p) { - if (path.isAbsolute(p)) { - return p; - } - return path.join(config.projectPath, p); - } - - logger.log('Opening report.'); - return open(toAbsolute(config.compareReportURL), {wait: false}); + const remoteReportUrl = 'http://127.0.0.1:3000/' + config.compareReportURL; + return new Promise(function (resolve, reject) { + // would prefer to ping a http://127.0.0.1:3000/remote with {backstopRemote:ok} response + logger.log('Attempting to ping ', remoteReportUrl); + http.get(remoteReportUrl, (resp) => { + let data = ''; + resp.on('data', (chunk) => { data += chunk; }); + resp.on('end', () => { + if (BACKSTOP_REPORT_SIGNATURE_RE.test(data)) { + logger.log('Remote found. Opening ' + remoteReportUrl); + resolve(open(remoteReportUrl, { wait: false })); + } else { + logger.log('Remote not detected. Opening ' + config.compareReportURL); + resolve(open(config.compareReportURL, { wait: false })); + } + }); + }).on('error', (err) => { + logger.log('Remote not found. Opening ' + config.compareReportURL, 'Error: ' + err.message); + resolve(open(path.resolve(config.compareReportURL), { wait: false })); + }); + }); } }; diff --git a/core/command/remote.js b/core/command/remote.js new file mode 100644 index 000000000..0ebf7327f --- /dev/null +++ b/core/command/remote.js @@ -0,0 +1,23 @@ +const logger = require('../util/logger')('remote'); +const path = require('path'); +const { exec } = require('child_process'); + +module.exports = { + execute: function (config) { + logger.log('Starting remote.'); + return new Promise(function (resolve, reject) { + const ssws = path.resolve(config.backstop, 'node_modules', 'super-simple-web-server', 'index.js'); + const child = exec(`node ${ssws} ${path.resolve(config.projectPath)}`); + child.stdout.on('data', (data) => { + // if (/someOutputWhichWouldCloseConnection/.test(data)) { + // resolve(); + // } + logger.log(data); + }); + child.stdout.on('close', (data) => { + logger.log('Server connection closed.', data); + resolve(data); + }); + }); + } +}; diff --git a/core/runner.js b/core/runner.js index 0ffdce248..a87517589 100644 --- a/core/runner.js +++ b/core/runner.js @@ -5,3 +5,52 @@ module.exports = function (command, options) { var config = makeConfig(command, options); return executeCommand(command, config); }; + +/* *** +// Sample of the config object that is created on `backstop init` by makeConfig() + +{ args: + { _: [ 'init' ], + h: false, + help: false, + v: false, + version: false, + i: false, + config: 'backstop.json' + }, + backstop: '/Users/gshipon/Development/BackstopJS', + projectPath: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD', + perf: { init: { started: 2018-09-23T04:01:09.673Z } }, + backstopConfigFileName: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop.json', + bitmaps_reference: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/bitmaps_reference', + bitmaps_test: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/bitmaps_test', + ci_report: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/ci_report', + ciReport: + { + format: 'junit', + testReportFileName: 'xunit', + testSuiteName: 'BackstopJS' + }, + html_report: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/html_report', + openReport: true, + compareConfigFileName: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/html_report/config.js', + compareReportURL: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/html_report/index.html', + comparePath: '/Users/gshipon/Development/BackstopJS/compare/output', + tempCompareConfigFileName: '/var/folders/9h/wrnjdvhj2qj48yj73d9sblsw000gs9/T/118822-2689-1h46kp1.3jzk.json', + captureConfigFileName: '/var/folders/9h/wrnjdvhj2qj48yj73d9sblsw000gs9/T/capture/33365765a815d9578b5cde5a8358b4ef3cfe2e90.json', + captureConfigFileNameDefault: '/Users/gshipon/Development/BackstopJS/capture/config.default.json', + casper_scripts: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/casper_scripts', + casper_scripts_default: '/Users/gshipon/Development/BackstopJS/capture/casper_scripts', + casperFlags: null, + engine_scripts: '/Users/gshipon/Development/BackstopJS/test/configs/test_TBD/backstop_data/engine_scripts', + engine_scripts_default: '/Users/gshipon/Development/BackstopJS/capture/engine_scripts', + id: undefined, + engine: null, + report: [ 'browser' ], + defaultMisMatchThreshold: 0.1, + debug: false, + resembleOutputOptions: undefined, + asyncCompareLimit: undefined, + backstopVersion: '3.5.14' +} +*** */ diff --git a/core/util/makeConfig.js b/core/util/makeConfig.js index 58956006f..83695dbc9 100644 --- a/core/util/makeConfig.js +++ b/core/util/makeConfig.js @@ -33,7 +33,7 @@ function loadProjectConfig (command, options, config) { } var userConfig = {}; - var CMD_REQUIRES_CONFIG = command !== 'genConfig'; + var CMD_REQUIRES_CONFIG = command !== 'init'; if (CMD_REQUIRES_CONFIG) { // This flow is confusing -- is checking for !config.backstopConfigFileName more reliable? if (options && typeof options.config === 'object' && options.config.scenarios) { diff --git a/examples/myCoolProject/readme.md b/examples/myCoolProject/readme.md index 9fc0d29eb..f51c101db 100644 --- a/examples/myCoolProject/readme.md +++ b/examples/myCoolProject/readme.md @@ -1,7 +1,7 @@ ### My Cool Project -do `backstop genConfig` then replace scenario with... +do `backstop init` then replace scenario with... ``` { diff --git a/examples/responsiveDemo/backstop.json b/examples/responsiveDemo/backstop.json new file mode 100644 index 000000000..c05714e83 --- /dev/null +++ b/examples/responsiveDemo/backstop.json @@ -0,0 +1,54 @@ +{ + "id": "responsiveDemoPage", + "viewports": [ + { + "label": "phone", + "width": 320, + "height": 480 + }, + { + "label": "tablet", + "width": 1024, + "height": 768 + } + ], + "onBeforeScript": "puppet/onBefore.js", + "onReadyScript": "puppet/onReady.js", + "scenarios": [ + { + "label": "comparePage", + "cookiePath": "backstop_data/engine_scripts/cookies.json", + "url": "http://127.0.0.1:3000/", + "referenceUrl": "", + "readyEvent": "", + "readySelector": "", + "delay": 100, + "hideSelectors": [], + "removeSelectors": [], + "hoverSelector": "", + "clickSelector": "", + "postInteractionWait": 0, + "selectors": [], + "selectorExpansion": true, + "expect": 0, + "misMatchThreshold" : 0.1, + "requireSameDimensions": true + } + ], + "paths": { + "bitmaps_reference": "backstop_data/bitmaps_reference", + "bitmaps_test": "backstop_data/bitmaps_test", + "engine_scripts": "backstop_data/engine_scripts", + "html_report": "backstop_data/html_report", + "ci_report": "backstop_data/ci_report" + }, + "report": ["browser"], + "engine": "puppeteer", + "engineOptions": { + "args": ["--no-sandbox"] + }, + "asyncCaptureLimit": 5, + "asyncCompareLimit": 50, + "debug": false, + "debugWindow": false +} diff --git a/examples/responsiveDemo/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_0_phone.png b/examples/responsiveDemo/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_0_phone.png new file mode 100644 index 0000000000000000000000000000000000000000..57b9dd23bf7ec9b16dda57fef3a85997a3046746 GIT binary patch literal 118187 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 Tqm6J=6#VF74YXcp*xddXQIFAb literal 0 HcmV?d00001 diff --git a/examples/responsiveDemo/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_1_tablet.png b/examples/responsiveDemo/backstop_data/bitmaps_reference/backstop_default_BackstopJS_Homepage_0_document_1_tablet.png new file mode 100644 index 0000000000000000000000000000000000000000..c8422e79d0d8c9cc16efefea47673e2dc81600e1 GIT binary patch literal 115229 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 V`jJw}Du}#F@}aDF&Vy&3{|!ywq=5hc literal 0 HcmV?d00001 diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/casper/clickAndHoverHelper.js b/examples/responsiveDemo/backstop_data/engine_scripts/casper/clickAndHoverHelper.js new file mode 100644 index 000000000..27406ec48 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/casper/clickAndHoverHelper.js @@ -0,0 +1,25 @@ +var WAIT_TIMEOUT = 5000; + +module.exports = function (casper, scenario) { + var waitFor = require('./waitForHelperHelper')(casper, WAIT_TIMEOUT); + var hoverSelector = scenario.hoverSelector; + var clickSelector = scenario.clickSelector; + var postInteractionWait = scenario.postInteractionWait; + + if (hoverSelector) { + waitFor(hoverSelector); + casper.then(function () { + casper.mouse.move(hoverSelector); + }); + } + + if (clickSelector) { + waitFor(clickSelector); + casper.then(function () { + casper.click(clickSelector); + }); + } + + // TODO: if postInteractionWait === integer then do ==> wait(postInteractionWait) || elsevvv + waitFor(postInteractionWait); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/casper/loadCookies.js b/examples/responsiveDemo/backstop_data/engine_scripts/casper/loadCookies.js new file mode 100644 index 000000000..3c1ad0e6e --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/casper/loadCookies.js @@ -0,0 +1,15 @@ +var fs = require('fs'); + +module.exports = function (casper, scenario) { + var cookies = []; + var cookiePath = scenario.cookiePath; + + // READ COOKIES FROM FILE IF EXISTS + if (fs.exists(cookiePath)) { + cookies = JSON.parse(fs.read(cookiePath)); + } + + casper.page.cookies = cookies; + console.log('Cookie state restored with cookies:', JSON.stringify(cookies, null, 2)); + casper.userAgent('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36'); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/casper/onBefore.js b/examples/responsiveDemo/backstop_data/engine_scripts/casper/onBefore.js new file mode 100644 index 000000000..785c4ecf7 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/casper/onBefore.js @@ -0,0 +1,4 @@ +module.exports = function (casper, scenario, vp) { + require('./loadCookies')(casper, scenario); + casper.userAgent('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/52.0.2743.116 Safari/537.36'); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/casper/onReady.js b/examples/responsiveDemo/backstop_data/engine_scripts/casper/onReady.js new file mode 100644 index 000000000..959a443a6 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/casper/onReady.js @@ -0,0 +1,5 @@ +module.exports = function (casper, scenario, vp) { + console.log('SCENARIO> ' + scenario.label); + require('./clickAndHoverHelper')(casper, scenario); + // add more helpers here... +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/casper/waitForHelperHelper.js b/examples/responsiveDemo/backstop_data/engine_scripts/casper/waitForHelperHelper.js new file mode 100644 index 000000000..682eb3bcb --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/casper/waitForHelperHelper.js @@ -0,0 +1,18 @@ +var TIMEOUT_DEFAULT = 2000; + +module.exports = function (casper, timeout) { + var TIMEOUT = timeout || TIMEOUT_DEFAULT; + + return function waitFor (selector) { + if (selector) { + casper.waitForSelector( + selector, + function () {}, + function () { + console.error('NOT FOUND > ' + selector); + }, + TIMEOUT + ); + } + }; +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/chromy/clickAndHoverHelper.js b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/clickAndHoverHelper.js new file mode 100644 index 000000000..d0bdccbc9 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/clickAndHoverHelper.js @@ -0,0 +1,34 @@ +module.exports = function (chromy, scenario) { + var hoverSelector = scenario.hoverSelectors || scenario.hoverSelector; + var clickSelector = scenario.clickSelectors || scenario.clickSelector; + var scrollToSelector = scenario.scrollToSelectors || scenario.scrollToSelector; + var postInteractionWait = scenario.postInteractionWait; // selector [str] | ms [int] + + if (hoverSelector) { + chromy + .wait(hoverSelector) + .rect(hoverSelector) + .result(function (rect) { + chromy.mouseMoved(rect.left, rect.top); + }); + } + + if (clickSelector) { + chromy + .wait(clickSelector) + .click(clickSelector); + } + + if (postInteractionWait) { + chromy.wait(postInteractionWait); + } + + if (scrollToSelector) { + chromy + .wait(scrollToSelector) + .evaluate(`window._scrollToSelector = '${scrollToSelector}'`) + .evaluate(function() { + document.querySelector(window._scrollToSelector).scrollIntoView(); + }); + } +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/chromy/loadCookies.js b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/loadCookies.js new file mode 100644 index 000000000..7d5a165b6 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/loadCookies.js @@ -0,0 +1,22 @@ +var fs = require('fs'); + +module.exports = function (chromy, scenario) { + var cookies = []; + var cookiePath = scenario.cookiePath; + + // READ COOKIES FROM FILE IF EXISTS + if (fs.existsSync(cookiePath)) { + cookies = JSON.parse(fs.readFileSync(cookiePath)); + } + + // MUNGE COOKIE DOMAIN FOR CHROMY USAGE + cookies = cookies.map(cookie => { + cookie.url = 'https://' + cookie.domain; + delete cookie.domain; + return cookie; + }); + + // SET COOKIES VIA CHROMY + chromy.setCookie(cookies); + console.log('Cookie state restored with:', JSON.stringify(cookies, null, 2)); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/chromy/onBefore.js b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/onBefore.js new file mode 100644 index 000000000..e174ef8b4 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/onBefore.js @@ -0,0 +1,6 @@ +module.exports = function (chromy, scenario, vp) { + require('./loadCookies')(chromy, scenario); + + // IGNORE ANY CERT WARNINGS + chromy.ignoreCertificateErrors(); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/chromy/onReady.js b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/onReady.js new file mode 100644 index 000000000..6238af804 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/chromy/onReady.js @@ -0,0 +1,5 @@ +module.exports = function (chromy, scenario, vp) { + console.log('SCENARIO > ' + scenario.label); + require('./clickAndHoverHelper')(chromy, scenario); + // add more ready handlers here... +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/cookies.json b/examples/responsiveDemo/backstop_data/engine_scripts/cookies.json new file mode 100644 index 000000000..b59400d7e --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/cookies.json @@ -0,0 +1,14 @@ +[ + { + "domain": ".www.yourdomain.com", + "path": "/", + "name": "yourCookieName", + "value": "yourCookieValue", + "expirationDate": 1798790400, + "hostOnly": false, + "httpOnly": false, + "secure": false, + "session": false, + "sameSite": "no_restriction" + } +] diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/imageStub.jpg b/examples/responsiveDemo/backstop_data/engine_scripts/imageStub.jpg new file mode 100644 index 0000000000000000000000000000000000000000..3e526b4bbbc74ef5125cb58f7c8849497ef4fa83 GIT binary patch literal 2900 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 literal 0 HcmV?d00001 diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/puppet/clickAndHoverHelper.js b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/clickAndHoverHelper.js new file mode 100644 index 000000000..81e0c9b37 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/clickAndHoverHelper.js @@ -0,0 +1,31 @@ +module.exports = async (page, scenario) => { + var hoverSelector = scenario.hoverSelectors || scenario.hoverSelector; + var clickSelector = scenario.clickSelectors || scenario.clickSelector; + var scrollToSelector = scenario.scrollToSelector; + var postInteractionWait = scenario.postInteractionWait; // selector [str] | ms [int] + + if (hoverSelector) { + for (const hoverSelectorIndex of [].concat(hoverSelector)) { + await page.waitFor(hoverSelectorIndex); + await page.hover(hoverSelectorIndex); + } + } + + if (clickSelector) { + for (const clickSelectorIndex of [].concat(clickSelector)) { + await page.waitFor(clickSelectorIndex); + await page.click(clickSelectorIndex); + } + } + + if (postInteractionWait) { + await page.waitFor(postInteractionWait); + } + + if (scrollToSelector) { + await page.waitFor(scrollToSelector); + await page.evaluate(scrollToSelector => { + document.querySelector(scrollToSelector).scrollIntoView(); + }, scrollToSelector); + } +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/puppet/ignoreCSP.js b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/ignoreCSP.js new file mode 100644 index 000000000..5e4f14155 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/ignoreCSP.js @@ -0,0 +1,65 @@ +/** + * IGNORE CSP HEADERS + * Listen to all requests. If a request matches scenario.url + * then fetch the request again manually, strip out CSP headers + * and respond to the original request without CSP headers. + * Allows `ignoreHTTPSErrors: true` BUT... requires `debugWindow: true` + * + * see https://github.com/GoogleChrome/puppeteer/issues/1229#issuecomment-380133332 + * this is the workaround until Page.setBypassCSP lands... https://github.com/GoogleChrome/puppeteer/pull/2324 + * + * @param {REQUEST} request + * @return {VOID} + * + * Use this in an onBefore script E.G. + ``` + module.exports = async function(page, scenario) { + require('./removeCSP')(page, scenario); + } + ``` + * + */ + +const fetch = require('node-fetch'); +const https = require('https'); +const agent = new https.Agent({ + rejectUnauthorized: false +}); + +module.exports = async function (page, scenario) { + const intercept = async (request, targetUrl) => { + const requestUrl = request.url(); + + // FIND TARGET URL REQUEST + if (requestUrl === targetUrl) { + const cookiesList = await page.cookies(requestUrl); + const cookies = cookiesList.map(cookie => `${cookie.name}=${cookie.value}`).join('; '); + const headers = Object.assign(request.headers(), {cookie: cookies}); + const options = { + headers: headers, + body: request.postData(), + method: request.method(), + follow: 20, + agent + }; + + const result = await fetch(requestUrl, options); + + const buffer = await result.buffer(); + let cleanedHeaders = result.headers._headers || {}; + cleanedHeaders['content-security-policy'] = ''; + await request.respond({ + body: buffer, + headers: cleanedHeaders, + status: result.status + }); + } else { + request.continue(); + } + }; + + await page.setRequestInterception(true); + page.on('request', req => { + intercept(req, scenario.url); + }); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/puppet/interceptImages.js b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/interceptImages.js new file mode 100644 index 000000000..c6c5ed391 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/interceptImages.js @@ -0,0 +1,37 @@ +/** + * INTERCEPT IMAGES + * Listen to all requests. If a request matches IMAGE_URL_RE + * then stub the image with data from IMAGE_STUB_URL + * + * Use this in an onBefore script E.G. + ``` + module.exports = async function(page, scenario) { + require('./interceptImages')(page, scenario); + } + ``` + * + */ + +const fs = require('fs'); +const path = require('path'); + +const IMAGE_URL_RE = /\.gif|\.jpg|\.png/i; +const IMAGE_STUB_URL = path.resolve(__dirname, '../../imageStub.jpg'); +const IMAGE_DATA_BUFFER = fs.readFileSync(IMAGE_STUB_URL); +const HEADERS_STUB = {}; + +module.exports = async function (page, scenario) { + const intercept = async (request, targetUrl) => { + if (IMAGE_URL_RE.test(request.url())) { + await request.respond({ + body: IMAGE_DATA_BUFFER, + headers: HEADERS_STUB, + status: 200 + }); + } else { + request.continue(); + } + }; + await page.setRequestInterception(true); + page.on('request', intercept); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/puppet/loadCookies.js b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/loadCookies.js new file mode 100644 index 000000000..db848a7cc --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/loadCookies.js @@ -0,0 +1,29 @@ +var fs = require('fs'); + +module.exports = async (page, scenario) => { + var cookies = []; + var cookiePath = scenario.cookiePath; + + // READ COOKIES FROM FILE IF EXISTS + if (fs.existsSync(cookiePath)) { + cookies = JSON.parse(fs.readFileSync(cookiePath)); + } + + // MUNGE COOKIE DOMAIN + cookies = cookies.map(cookie => { + cookie.url = 'https://' + cookie.domain; + delete cookie.domain; + return cookie; + }); + + // SET COOKIES + const setCookies = async () => { + return Promise.all( + cookies.map(async (cookie) => { + await page.setCookie(cookie); + }) + ); + }; + await setCookies(); + console.log('Cookie state restored with:', JSON.stringify(cookies, null, 2)); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/puppet/onBefore.js b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/onBefore.js new file mode 100644 index 000000000..a1c374c37 --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/onBefore.js @@ -0,0 +1,3 @@ +module.exports = async (page, scenario, vp) => { + await require('./loadCookies')(page, scenario); +}; diff --git a/examples/responsiveDemo/backstop_data/engine_scripts/puppet/onReady.js b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/onReady.js new file mode 100644 index 000000000..517c0e41b --- /dev/null +++ b/examples/responsiveDemo/backstop_data/engine_scripts/puppet/onReady.js @@ -0,0 +1,6 @@ +module.exports = async (page, scenario, vp) => { + console.log('SCENARIO > ' + scenario.label); + await require('./clickAndHoverHelper')(page, scenario); + + // add more ready handlers here... +}; diff --git a/examples/responsiveDemo/index.html b/examples/responsiveDemo/index.html index 1dc3d1f0a..556cd3232 100755 --- a/examples/responsiveDemo/index.html +++ b/examples/responsiveDemo/index.html @@ -16,6 +16,9 @@