Yajbir Singh
677 lines
19 KiB
JavaScript
677 lines
19 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2024
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
(function ()
|
|
{
|
|
/**
|
|
* Класс, восстанавливающий удаленные части документа
|
|
* @param {AscWord.Document} logicDocument
|
|
* @constructor
|
|
*/
|
|
function DeletedTextRecovery(logicDocument)
|
|
{
|
|
this.document = logicDocument;
|
|
|
|
/**
|
|
* Список всех изменений связанных с удалением текста
|
|
* @type {*[]}
|
|
*/
|
|
this.m_RewiewDelPoints = [];
|
|
this.arrColor = [];
|
|
|
|
this.userId = undefined;
|
|
this.userName = undefined;
|
|
this.userTime = undefined;
|
|
}
|
|
/**
|
|
* Восстанавливаем удаленный текст в текущей точке истории версий
|
|
* @return {boolean}
|
|
*/
|
|
DeletedTextRecovery.prototype.RecoverDeletedText = function()
|
|
{
|
|
this.UndoRecoveredText();
|
|
return this.ShowDelText();
|
|
};
|
|
/**
|
|
* Отменяем восстановление удаленного текста, если оно было
|
|
*/
|
|
DeletedTextRecovery.prototype.UndoRecoveredText = function ()
|
|
{
|
|
if (!this.HaveRecoveredText())
|
|
return;
|
|
|
|
let localHistory = AscCommon.History;
|
|
let changes = localHistory.Undo();
|
|
this.document.UpdateAfterUndoRedo(changes);
|
|
localHistory.ClearRedo();
|
|
};
|
|
/**
|
|
* Запрашивем,есть ли восстановленный удаленный текст
|
|
* @return {boolean}
|
|
*/
|
|
DeletedTextRecovery.prototype.HaveRecoveredText = function()
|
|
{
|
|
let localHistory = AscCommon.History;
|
|
let lastPoint = localHistory.Points[localHistory.Points.length - 1];
|
|
return !!(lastPoint && lastPoint.Description === AscDFH.historydescription_Collaborative_DeletedTextRecovery);
|
|
};
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Private area
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
/**
|
|
* Инициализация и создание промежуточных данных для отображения удаленного текста в текущей ревизии
|
|
*/
|
|
DeletedTextRecovery.prototype.HandleChanges = function()
|
|
{
|
|
AscCommon.CollaborativeEditing.CoHistory.SplitChangesByPoints();
|
|
|
|
let oCoHistory = AscCommon.CollaborativeEditing.CoHistory;
|
|
let arrChangesList = oCoHistory.Changes;
|
|
let arrPointsList = AscCommon.CollaborativeEditing.CoHistory.ChangesSplitByPoints;
|
|
let nIndex = AscCommon.CollaborativeEditing.CoHistory.curChangeIndex;
|
|
let arrChanges = arrChangesList.slice(0, arrPointsList[nIndex]);
|
|
|
|
if (!arrChanges || !arrChanges.length)
|
|
return;
|
|
|
|
this.m_RewiewDelPoints = arrChanges;
|
|
};
|
|
/**
|
|
* Получаем подготовленные данные, разбитые по точкам
|
|
* @return {*[]}
|
|
*/
|
|
DeletedTextRecovery.prototype.GetChanges = function()
|
|
{
|
|
let arr = this.m_RewiewDelPoints.slice();
|
|
|
|
let arrOutput = []
|
|
for (let i = 0; i < arr.length; i++)
|
|
{
|
|
let oChange = arr[i];
|
|
if (oChange.ConvertToSimpleChanges)
|
|
{
|
|
let arrSplitChange = oChange.ConvertToSimpleChanges();
|
|
if (arrSplitChange && arrSplitChange.length)
|
|
{
|
|
for (let j = 0; j < arrSplitChange.length; j++)
|
|
{
|
|
arrOutput.push(arrSplitChange[j])
|
|
}
|
|
} else
|
|
{
|
|
arrOutput.push(oChange);
|
|
}
|
|
}
|
|
else
|
|
arrOutput.push(oChange);
|
|
|
|
}
|
|
return arrOutput;
|
|
};
|
|
DeletedTextRecovery.prototype.GetRemoveTextChanges = function (arrInputChanges, oRemoveText)
|
|
{
|
|
let oAddText = new AddTextPositions();
|
|
|
|
// отбираем удаленный текст связанный с текущей ревизией
|
|
for (let i = 0; i < arrInputChanges.length; i++)
|
|
{
|
|
let oCurChange = arrInputChanges[i];
|
|
|
|
// пропускаем все изменения связанные со сплитом
|
|
if (oCurChange instanceof CChangesRunOnStartSplit)
|
|
{
|
|
while (oCurChange && !(oCurChange instanceof CChangesRunOnEndSplit))
|
|
{
|
|
i++;
|
|
oCurChange = arrInputChanges[i];
|
|
}
|
|
}
|
|
|
|
if (oCurChange === undefined)
|
|
break;
|
|
|
|
if (oCurChange instanceof AscCommon.CChangesTableIdDescription || !oCurChange.Copy)
|
|
continue;
|
|
|
|
let oNewCurChange = oCurChange.Copy();
|
|
|
|
oRemoveText.ProceedChange(oNewCurChange);
|
|
|
|
if (oNewCurChange instanceof CChangesRunAddItem || oNewCurChange instanceof CChangesParagraphAddItem || oNewCurChange instanceof CChangesDocumentAddItem)
|
|
oAddText.Add(oCurChange.Class, oCurChange, oCurChange.UseArray ? oCurChange.PosArray[0] : oCurChange.Pos, i);
|
|
else if (oNewCurChange instanceof CChangesRunRemoveItem || oNewCurChange instanceof CChangesParagraphRemoveItem || oNewCurChange instanceof CChangesDocumentRemoveItem)
|
|
oRemoveText.Check(oAddText, oCurChange, i);
|
|
}
|
|
oRemoveText.DelDuplicate();
|
|
}
|
|
DeletedTextRecovery.prototype.CommuteChanges = function (arrInputChanges, arrSaveData, oRemoveText)
|
|
{
|
|
// коммутируем изменения
|
|
let arrRevInput = arrInputChanges;
|
|
|
|
let arrDelChangesForCommute = oRemoveText.GetArrayChanges();
|
|
|
|
for (let j = 0; j < arrDelChangesForCommute.length; j++)
|
|
{
|
|
let oCurItem = arrDelChangesForCommute[j];
|
|
let nPos = oCurItem.nIndex;
|
|
let oChange = oCurItem.item;
|
|
|
|
if (oChange.IsContentChange())
|
|
{
|
|
let _oChange = oChange.Copy();
|
|
|
|
if (AscCommon.CollaborativeEditing.CoHistory.CommuteContentChange(_oChange, nPos, arrRevInput))
|
|
arrSaveData.push(_oChange);
|
|
}
|
|
else
|
|
{
|
|
arrSaveData.push(oChange);
|
|
}
|
|
}
|
|
|
|
oRemoveText.ResetData();
|
|
}
|
|
/**
|
|
* Отменяем заданные изменения
|
|
* @param arrInputChanges
|
|
* @return {*[]}
|
|
*/
|
|
DeletedTextRecovery.prototype.RedoUndoChanges = function (arrInputChanges)
|
|
{
|
|
let oRemoveText = new RemoveTextPositions();
|
|
let arrChanges = [];
|
|
let arrDelChanges = [];
|
|
|
|
this.GetRemoveTextChanges(arrInputChanges, oRemoveText);
|
|
this.CommuteChanges(arrInputChanges, arrDelChanges, oRemoveText);
|
|
|
|
for (let i = 0; i < arrDelChanges.length; i++)
|
|
{
|
|
this.RedoUndoChange(arrDelChanges[i], false, arrChanges);
|
|
let nPos = arrDelChanges[i].UseArray
|
|
? arrDelChanges[i].PosArray[0]
|
|
: arrDelChanges[i].Pos;
|
|
|
|
oRemoveText.Add(
|
|
arrDelChanges[i].Class,
|
|
arrDelChanges[i],
|
|
nPos,
|
|
i
|
|
);
|
|
}
|
|
|
|
let result = {
|
|
data: oRemoveText.ProceedPositions(this),
|
|
classes: oRemoveText.oClasses
|
|
};
|
|
|
|
return [arrChanges, result];
|
|
};
|
|
DeletedTextRecovery.prototype.ShowDelText = function ()
|
|
{
|
|
let versionHistory = this.document.GetApi().getVersionHistory();
|
|
if (!versionHistory)
|
|
return false;
|
|
|
|
this.HandleChanges();
|
|
let arrInput = this.GetChanges();
|
|
if (arrInput.length === 0)
|
|
return false;
|
|
|
|
let localHistory = AscCommon.History;
|
|
localHistory.Create_NewPoint(AscDFH.historydescription_Collaborative_DeletedTextRecovery);
|
|
|
|
this.userId = versionHistory.userId;
|
|
this.userName = versionHistory.userName;
|
|
this.userTime = new Date(versionHistory.dateOfRevision).getTime();
|
|
|
|
// отменяем изменения до нужного места (необходимо для перемещения по истории)
|
|
let arrCurrentPoint = this.RedoUndoChanges(arrInput);
|
|
let delChanges = arrCurrentPoint[0];
|
|
let arrResult = arrCurrentPoint[1];
|
|
|
|
for (let i = 0; i < delChanges.length; i++)
|
|
{
|
|
this.document.History.Add(delChanges[i]);
|
|
}
|
|
this.Split(arrResult);
|
|
this.document.RecalculateByChanges(delChanges);
|
|
|
|
this.m_RewiewDelPoints = [];
|
|
return true;
|
|
};
|
|
DeletedTextRecovery.prototype.Split = function (arrInput)
|
|
{
|
|
let data = arrInput.data;
|
|
let classes = arrInput.classes;
|
|
let arrKeys = Object.keys(data);
|
|
|
|
for (let nKey = 0; nKey < arrKeys.length; nKey++)
|
|
{
|
|
let strCurrentKey = arrKeys[nKey];
|
|
let arrCurrentRunData = data[strCurrentKey];
|
|
let oCurrentRun = classes[strCurrentKey];
|
|
|
|
arrCurrentRunData.sort(function (a, b) { return a.nStart - b.nStart });
|
|
|
|
for (let j = arrCurrentRunData.length - 1; j >= 0; j--)
|
|
{
|
|
let oCurrentRule = arrCurrentRunData[j];
|
|
let nStart = oCurrentRule.nStart;
|
|
let nEnd = oCurrentRule.nEnd;
|
|
|
|
if (oCurrentRun instanceof CDocument)
|
|
{
|
|
let arrContent = oCurrentRun.Content;
|
|
|
|
for (let j = nStart; j <= nEnd; j++)
|
|
{
|
|
let oCurrentParagraph = arrContent[j];
|
|
if (oCurrentParagraph)
|
|
this.SetReviewInfo(oCurrentParagraph);
|
|
}
|
|
}
|
|
else if (oCurrentRun instanceof Paragraph)
|
|
{
|
|
let arrContent = oCurrentRun.Content;
|
|
|
|
if (nStart === 0 && arrContent.length === nEnd)
|
|
{
|
|
this.SetReviewInfo(oCurrentRun);
|
|
}
|
|
else
|
|
{
|
|
for (let i = nStart; i <= nEnd; i++)
|
|
{
|
|
this.SetReviewInfo(arrContent[i]);
|
|
}
|
|
}
|
|
}
|
|
else if (oCurrentRun instanceof ParaRun)
|
|
{
|
|
let newCollab = [];
|
|
|
|
if (oCurrentRun.Content.length === 0 || (nEnd + 1 - nStart) === oCurrentRun.Content.length)
|
|
{
|
|
this.SetReviewInfo(oCurrentRun);
|
|
continue;
|
|
}
|
|
|
|
for (let i = 0; i < oCurrentRun.CollaborativeMarks.Ranges.length; i++)
|
|
{
|
|
let oCollab = oCurrentRun.CollaborativeMarks.Ranges[i];
|
|
newCollab.push({PosS: oCollab.PosS, PosE: oCollab.PosE, Color: oCollab.Color, oCurrentRun: oCurrentRun});
|
|
}
|
|
|
|
let oParent = oCurrentRun.GetParent();
|
|
let RunPos = this.FindPosInParent(oCurrentRun);
|
|
let RightRun = oCurrentRun.SplitForSpreadCollaborativeMark(nStart);
|
|
|
|
oParent.Add_ToContent(RunPos + 1, RightRun);
|
|
let oNewer = RightRun.SplitForSpreadCollaborativeMark(nEnd - nStart + 1);
|
|
|
|
oParent.Add_ToContent(RunPos + 2, oNewer);
|
|
this.SetReviewInfo(RightRun);
|
|
|
|
for (let i = 0; i < newCollab.length; i++)
|
|
{
|
|
let oCurCollaborativeMark = newCollab[i];
|
|
this.arrColor.push(oCurCollaborativeMark);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
DeletedTextRecovery.prototype.SetReviewInfo = function (oReviewInfoParent)
|
|
{
|
|
if (!oReviewInfoParent === undefined)
|
|
return;
|
|
|
|
// TODO: Проверку по каким классам нужно проходить лучше переделать
|
|
if (!oReviewInfoParent || !oReviewInfoParent.GetReviewInfo)
|
|
{
|
|
if (oReviewInfoParent instanceof ParaMath)
|
|
{
|
|
let oRootContent = oReviewInfoParent.Root.Content;
|
|
for (let i = 0; i < oRootContent.length; i++)
|
|
{
|
|
let oCurrentContent = oRootContent[i];
|
|
this.SetReviewInfo(oCurrentContent);
|
|
}
|
|
}
|
|
else if (oReviewInfoParent.Content.length > 0)
|
|
{
|
|
for (let i = 0; i < oReviewInfoParent.Content.length; i++)
|
|
{
|
|
let oCurrentContent = oReviewInfoParent.Content[i];
|
|
this.SetReviewInfo(oCurrentContent);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (oReviewInfoParent.GetReviewType() !== reviewtype_Remove)
|
|
{
|
|
let reviewInfo = oReviewInfoParent.GetReviewInfo();
|
|
if (!reviewInfo)
|
|
reviewInfo = new AscWord.ReviewInfo();
|
|
else
|
|
reviewInfo = reviewInfo.Copy();
|
|
|
|
reviewInfo.UserId = this.userId;
|
|
reviewInfo.UserName = this.userName;
|
|
reviewInfo.DateTime = this.userTime;
|
|
|
|
oReviewInfoParent.SetReviewTypeWithInfo(reviewtype_Remove, reviewInfo, false);
|
|
}
|
|
};
|
|
DeletedTextRecovery.prototype.FindPosInParent = function(oClass)
|
|
{
|
|
let oParent = oClass.GetParent();
|
|
let arrParentContent = oParent.Content;
|
|
|
|
for (let i = 0; i < arrParentContent.length; i++)
|
|
{
|
|
if (arrParentContent[i] === oClass)
|
|
return i;
|
|
}
|
|
};
|
|
DeletedTextRecovery.prototype.RedoUndoChange = function (oChange, isRedo, arrToSave)
|
|
{
|
|
if (!oChange)
|
|
return;
|
|
|
|
if (oChange.IsContentChange())
|
|
{
|
|
let arrSimpleChanges = oChange.ConvertToSimpleChanges();
|
|
|
|
for (let simpleIndex = arrSimpleChanges.length - 1; simpleIndex >= 0; simpleIndex--)
|
|
{
|
|
if (isRedo)
|
|
arrSimpleChanges[simpleIndex].Redo();
|
|
else
|
|
arrSimpleChanges[simpleIndex].Undo();
|
|
|
|
|
|
let oRevChange = arrSimpleChanges[simpleIndex];
|
|
|
|
if (!isRedo)
|
|
oRevChange = oRevChange.CreateReverseChange();
|
|
|
|
if (oRevChange)
|
|
arrToSave.push(oRevChange);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (isRedo)
|
|
oChange.Redo();
|
|
else
|
|
oChange.Undo();
|
|
|
|
let oRevChange = oChange;
|
|
|
|
if (!isRedo)
|
|
oRevChange = oRevChange.CreateReverseChange();
|
|
|
|
if (oRevChange)
|
|
arrToSave.push(oRevChange);
|
|
}
|
|
};
|
|
|
|
function AddTextPositions()
|
|
{
|
|
this.data = {};
|
|
|
|
this.Add = function (oClass, oItem, Pos, nIndex)
|
|
{
|
|
if (!this.data[oClass.Id])
|
|
this.data[oClass.Id] = [];
|
|
|
|
this.data[oClass.Id].push({item: oItem, pos: Pos, nIndex: nIndex});
|
|
}
|
|
}
|
|
function RemoveTextPositions()
|
|
{
|
|
this.data = {};
|
|
this.oClasses = {};
|
|
this.arrClasses = [];
|
|
|
|
this.Check = function (oAddText, oCurChange, i)
|
|
{
|
|
if (oCurChange.Class)
|
|
{
|
|
let strCurrentId = oCurChange.Class.Id;
|
|
let arrRemData = oAddText.data[strCurrentId];
|
|
|
|
if (!arrRemData)
|
|
{
|
|
this.Add(oCurChange.Class, oCurChange, oCurChange.UseArray ? oCurChange.PosArray[0] : oCurChange.Pos, i);
|
|
return;
|
|
}
|
|
|
|
let addItem = oCurChange.Items[0];
|
|
|
|
for (let i = 0; i < arrRemData.length; i++)
|
|
{
|
|
let oCurrentRemItem = arrRemData[i];
|
|
|
|
if (oCurChange.UseArray && oCurChange.PosArray[0] === oCurrentRemItem.pos && addItem.Value === oCurrentRemItem.item.Items[0].Value)
|
|
{
|
|
return false;
|
|
}
|
|
else if (!oCurChange.UseArray && oCurChange.Pos === oCurrentRemItem.pos && addItem.Value === oCurrentRemItem.item.Items[0].Value)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.Add(oCurChange.Class, oCurChange, oCurChange.UseArray ? oCurChange.PosArray[0] : oCurChange.Pos, i);
|
|
}
|
|
this.DelDuplicate = function ()
|
|
{
|
|
let arrKeys = Object.keys(this.data);
|
|
|
|
for (let nKey = 0; nKey < arrKeys.length; nKey++)
|
|
{
|
|
let strCurrentKey = arrKeys[nKey];
|
|
let arrCurrentRunData = this.data[strCurrentKey];
|
|
|
|
for (let i = 0; i < arrCurrentRunData.length; i++)
|
|
{
|
|
for (let j = i + 1; j < arrCurrentRunData.length; j++)
|
|
{
|
|
if (arrCurrentRunData[i].item === arrCurrentRunData[j].item)
|
|
{
|
|
arrCurrentRunData.splice(j, 1);
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.Add = function (oClass, oItem, Pos, nIndex)
|
|
{
|
|
if (!this.data[oClass.Id])
|
|
this.data[oClass.Id] = [];
|
|
|
|
this.data[oClass.Id].push({item: oItem, pos: Pos, nIndex: nIndex});
|
|
}
|
|
this.GetArrayChanges = function ()
|
|
{
|
|
let arrOutput = []
|
|
let arrKeys = Object.keys(this.data);
|
|
|
|
for (let nKey = 0; nKey < arrKeys.length; nKey++)
|
|
{
|
|
let strCurrentKey = arrKeys[nKey];
|
|
let arrCurrentRunData = this.data[strCurrentKey];
|
|
|
|
for (let i = 0; i < arrCurrentRunData.length; i++)
|
|
{
|
|
arrOutput.push(arrCurrentRunData[i]);
|
|
}
|
|
}
|
|
return arrOutput;
|
|
}
|
|
this.ProceedChange = function (oChange)
|
|
{
|
|
if (oChange.Class && !this.oClasses[oChange.Class.Id])
|
|
{
|
|
this.oClasses[oChange.Class.Id] = oChange.Class;
|
|
if (-1 === this.arrClasses.indexOf(oChange.Class.Id))
|
|
{
|
|
this.arrClasses.push(oChange.Class.Id);
|
|
}
|
|
}
|
|
}
|
|
this.FindInParent = function (oClass, oItem)
|
|
{
|
|
let arrParentContent = oClass.Content;
|
|
|
|
for (let nPos = 0; nPos < arrParentContent.length; nPos++)
|
|
{
|
|
if (arrParentContent[nPos] === oItem)
|
|
return nPos;
|
|
}
|
|
}
|
|
this.ProceedPositions = function ()
|
|
{
|
|
for (let nKey = 0; nKey < this.arrClasses.length; nKey++)
|
|
{
|
|
let strCurrentKey = this.arrClasses[nKey];
|
|
let arrCurrentRunData = this.data[strCurrentKey];
|
|
if (!arrCurrentRunData)
|
|
continue;
|
|
let oClass = this.oClasses[strCurrentKey];
|
|
let newArrCurrentRunData = [];
|
|
|
|
for (let i = 0; i < arrCurrentRunData.length; i++)
|
|
{
|
|
let oItem = arrCurrentRunData[i];
|
|
|
|
let nPos = this.FindInParent(oClass, oItem.item.Items[0]);
|
|
newArrCurrentRunData.push(nPos);
|
|
}
|
|
|
|
let nCurrentPos;
|
|
let nPrevPos;
|
|
let nTempPrevPos;
|
|
|
|
for (let nPos = 1; nPos < newArrCurrentRunData.length; nPos++)
|
|
{
|
|
nPrevPos = newArrCurrentRunData[nPos - 1];
|
|
nCurrentPos = newArrCurrentRunData[nPos];
|
|
|
|
if (nTempPrevPos === nCurrentPos || nCurrentPos === nPrevPos)
|
|
{
|
|
if (nTempPrevPos)
|
|
{
|
|
nTempPrevPos = undefined;
|
|
newArrCurrentRunData[nPos] = nPrevPos + 1;
|
|
nTempPrevPos = nCurrentPos;
|
|
}
|
|
else
|
|
{
|
|
newArrCurrentRunData[nPos] = nCurrentPos + 1;
|
|
nTempPrevPos = nCurrentPos;
|
|
}
|
|
}
|
|
}
|
|
this.data[strCurrentKey] = newArrCurrentRunData;
|
|
}
|
|
let transformedObject = CollapsePositions(this.data);
|
|
return transformedObject
|
|
}
|
|
this.ResetData = function ()
|
|
{
|
|
this.data = {};
|
|
}
|
|
}
|
|
function CollapsePositions (oInput)
|
|
{
|
|
let transformedObject = {};
|
|
for (let key in oInput)
|
|
{
|
|
if (oInput.hasOwnProperty(key))
|
|
{
|
|
let values = oInput[key];
|
|
let pairs = [];
|
|
let nStart = null;
|
|
let nEnd = null;
|
|
let decreasingSequence = false;
|
|
|
|
for (let i = 0; i < values.length; i++)
|
|
{
|
|
let value = values[i];
|
|
|
|
if (nStart === null)
|
|
{
|
|
nStart = value;
|
|
nEnd = value;
|
|
}
|
|
else if (value === nEnd + 1)
|
|
{
|
|
nEnd = value;
|
|
decreasingSequence = false;
|
|
}
|
|
else if (value === nEnd - 1)
|
|
{
|
|
nStart = value;
|
|
decreasingSequence = true;
|
|
}
|
|
else
|
|
{
|
|
pairs.push({ nStart : nStart, nEnd: nEnd });
|
|
nStart = value;
|
|
nEnd = value;
|
|
decreasingSequence = false;
|
|
}
|
|
}
|
|
|
|
if (nStart !== null && nEnd !== null)
|
|
pairs.push({ nStart : nStart, nEnd: nEnd });
|
|
|
|
transformedObject[key] = pairs;
|
|
}
|
|
}
|
|
return transformedObject;
|
|
}
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
AscCommon.DeletedTextRecovery = DeletedTextRecovery;
|
|
|
|
})();
|