@teselagen/ove 0.0.4 → 0.0.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/index.js +549 -464
- package/index.mjs +549 -464
- package/index.umd.js +549 -464
- package/package.json +1 -1
package/index.js
CHANGED
|
@@ -29325,20 +29325,19 @@ function createField(structure2) {
|
|
|
29325
29325
|
_proto.shouldComponentUpdate = /* @__PURE__ */ __name(function shouldComponentUpdate(nextProps, nextState) {
|
|
29326
29326
|
return shallowCompare$1(this, nextProps, nextState);
|
|
29327
29327
|
}, "shouldComponentUpdate");
|
|
29328
|
-
_proto.
|
|
29329
|
-
var
|
|
29330
|
-
var
|
|
29331
|
-
var newName = prefixName(this.props, this.props.name);
|
|
29328
|
+
_proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
|
|
29329
|
+
var oldName = prefixName(this.props, this.props.name);
|
|
29330
|
+
var newName = prefixName(nextProps, nextProps.name);
|
|
29332
29331
|
if (oldName !== newName || // use deepEqual here because they could be a function or an array of functions
|
|
29333
|
-
!plain.deepEqual(
|
|
29332
|
+
!plain.deepEqual(this.props.validate, nextProps.validate) || !plain.deepEqual(this.props.warn, nextProps.warn)) {
|
|
29334
29333
|
this.props._reduxForm.unregister(oldName);
|
|
29335
29334
|
this.props._reduxForm.register(newName, "Field", function() {
|
|
29336
|
-
return
|
|
29335
|
+
return nextProps.validate;
|
|
29337
29336
|
}, function() {
|
|
29338
|
-
return
|
|
29337
|
+
return nextProps.warn;
|
|
29339
29338
|
});
|
|
29340
29339
|
}
|
|
29341
|
-
}, "
|
|
29340
|
+
}, "UNSAFE_componentWillReceiveProps");
|
|
29342
29341
|
_proto.componentWillUnmount = /* @__PURE__ */ __name(function componentWillUnmount() {
|
|
29343
29342
|
this.props._reduxForm.unregister(this.name);
|
|
29344
29343
|
}, "componentWillUnmount");
|
|
@@ -30311,14 +30310,14 @@ function createFieldArray(structure2) {
|
|
|
30311
30310
|
return wrapError(_this2.props.warn, "_warning");
|
|
30312
30311
|
});
|
|
30313
30312
|
}, "componentDidMount");
|
|
30314
|
-
_proto.
|
|
30315
|
-
var oldName = prefixName(
|
|
30316
|
-
var newName = prefixName(
|
|
30313
|
+
_proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
|
|
30314
|
+
var oldName = prefixName(this.props, this.props.name);
|
|
30315
|
+
var newName = prefixName(nextProps, nextProps.name);
|
|
30317
30316
|
if (oldName !== newName) {
|
|
30318
30317
|
this.props._reduxForm.unregister(oldName);
|
|
30319
30318
|
this.props._reduxForm.register(newName, "FieldArray");
|
|
30320
30319
|
}
|
|
30321
|
-
}, "
|
|
30320
|
+
}, "UNSAFE_componentWillReceiveProps");
|
|
30322
30321
|
_proto.componentWillUnmount = /* @__PURE__ */ __name(function componentWillUnmount() {
|
|
30323
30322
|
this.props._reduxForm.unregister(this.name);
|
|
30324
30323
|
}, "componentWillUnmount");
|
|
@@ -31013,8 +31012,8 @@ var getDisplayName$2 = /* @__PURE__ */ __name(function getDisplayName(Comp) {
|
|
|
31013
31012
|
}, "getDisplayName");
|
|
31014
31013
|
const getDisplayName$3 = getDisplayName$2;
|
|
31015
31014
|
var isHotReloading = /* @__PURE__ */ __name(function isHotReloading2() {
|
|
31016
|
-
var castModule =
|
|
31017
|
-
return !!(castModule && castModule.hot && typeof castModule.hot.status === "function" && castModule.hot.status() === "apply");
|
|
31015
|
+
var castModule = module;
|
|
31016
|
+
return !!(typeof castModule !== "undefined" && castModule.hot && typeof castModule.hot.status === "function" && castModule.hot.status() === "apply");
|
|
31018
31017
|
}, "isHotReloading");
|
|
31019
31018
|
const isHotReloading$1 = isHotReloading;
|
|
31020
31019
|
var isClassComponent = /* @__PURE__ */ __name(function isClassComponent2(Component) {
|
|
@@ -31081,7 +31080,6 @@ function createReduxForm(structure2) {
|
|
|
31081
31080
|
_this.lastFieldWarnerKeys = [];
|
|
31082
31081
|
_this.innerOnSubmit = void 0;
|
|
31083
31082
|
_this.submitPromise = void 0;
|
|
31084
|
-
_this.initializedOnLoad = false;
|
|
31085
31083
|
_this.initIfNeeded = function(nextProps) {
|
|
31086
31084
|
var enableReinitialize = _this.props.enableReinitialize;
|
|
31087
31085
|
if (nextProps) {
|
|
@@ -31092,16 +31090,13 @@ function createReduxForm(structure2) {
|
|
|
31092
31090
|
lastInitialValues: _this.props.initialValues,
|
|
31093
31091
|
updateUnregisteredFields: nextProps.updateUnregisteredFields
|
|
31094
31092
|
});
|
|
31095
|
-
return true;
|
|
31096
31093
|
}
|
|
31097
31094
|
} else if (_this.props.initialValues && (!_this.props.initialized || enableReinitialize)) {
|
|
31098
31095
|
_this.props.initialize(_this.props.initialValues, _this.props.keepDirtyOnReinitialize, {
|
|
31099
31096
|
keepValues: _this.props.keepValues,
|
|
31100
31097
|
updateUnregisteredFields: _this.props.updateUnregisteredFields
|
|
31101
31098
|
});
|
|
31102
|
-
return true;
|
|
31103
31099
|
}
|
|
31104
|
-
return false;
|
|
31105
31100
|
};
|
|
31106
31101
|
_this.updateSyncErrorsIfNeeded = function(nextSyncErrors, nextError, lastSyncErrors) {
|
|
31107
31102
|
var _this$props = _this.props, error2 = _this$props.error, updateSyncErrors3 = _this$props.updateSyncErrors;
|
|
@@ -31371,18 +31366,20 @@ function createReduxForm(structure2) {
|
|
|
31371
31366
|
_this.reset = function() {
|
|
31372
31367
|
return _this.props.reset();
|
|
31373
31368
|
};
|
|
31374
|
-
if (!isHotReloading$1()) {
|
|
31375
|
-
_this.initializedOnLoad = _this.initIfNeeded();
|
|
31376
|
-
}
|
|
31377
|
-
invariant$4(_this.props.shouldValidate, "shouldValidate() is deprecated and will be removed in v9.0.0. Use shouldWarn() or shouldError() instead.");
|
|
31378
31369
|
return _this;
|
|
31379
31370
|
}
|
|
31380
31371
|
__name(Form2, "Form");
|
|
31381
31372
|
var _proto = Form2.prototype;
|
|
31373
|
+
_proto.UNSAFE_componentWillMount = /* @__PURE__ */ __name(function UNSAFE_componentWillMount() {
|
|
31374
|
+
if (!isHotReloading$1()) {
|
|
31375
|
+
this.initIfNeeded();
|
|
31376
|
+
this.validateIfNeeded();
|
|
31377
|
+
this.warnIfNeeded();
|
|
31378
|
+
}
|
|
31379
|
+
invariant$4(this.props.shouldValidate, "shouldValidate() is deprecated and will be removed in v9.0.0. Use shouldWarn() or shouldError() instead.");
|
|
31380
|
+
}, "UNSAFE_componentWillMount");
|
|
31382
31381
|
_proto.UNSAFE_componentWillReceiveProps = /* @__PURE__ */ __name(function UNSAFE_componentWillReceiveProps(nextProps) {
|
|
31383
|
-
|
|
31384
|
-
if (isValueReset)
|
|
31385
|
-
return;
|
|
31382
|
+
this.initIfNeeded(nextProps);
|
|
31386
31383
|
this.validateIfNeeded(nextProps);
|
|
31387
31384
|
this.warnIfNeeded(nextProps);
|
|
31388
31385
|
this.clearSubmitPromiseIfNeeded(nextProps);
|
|
@@ -31406,8 +31403,7 @@ function createReduxForm(structure2) {
|
|
|
31406
31403
|
}, "shouldComponentUpdate");
|
|
31407
31404
|
_proto.componentDidMount = /* @__PURE__ */ __name(function componentDidMount() {
|
|
31408
31405
|
if (!isHotReloading$1()) {
|
|
31409
|
-
|
|
31410
|
-
return;
|
|
31406
|
+
this.initIfNeeded(this.props);
|
|
31411
31407
|
this.validateIfNeeded();
|
|
31412
31408
|
this.warnIfNeeded();
|
|
31413
31409
|
}
|
|
@@ -39463,25 +39459,16 @@ var toString$4 = {}.toString;
|
|
|
39463
39459
|
var _cof = /* @__PURE__ */ __name(function(it) {
|
|
39464
39460
|
return toString$4.call(it).slice(8, -1);
|
|
39465
39461
|
}, "_cof");
|
|
39466
|
-
var
|
|
39467
|
-
var
|
|
39468
|
-
|
|
39469
|
-
|
|
39470
|
-
return _iobject;
|
|
39471
|
-
hasRequired_iobject = 1;
|
|
39472
|
-
var cof2 = _cof;
|
|
39473
|
-
_iobject = Object("z").propertyIsEnumerable(0) ? Object : function(it) {
|
|
39474
|
-
return cof2(it) == "String" ? it.split("") : Object(it);
|
|
39475
|
-
};
|
|
39476
|
-
return _iobject;
|
|
39477
|
-
}
|
|
39478
|
-
__name(require_iobject, "require_iobject");
|
|
39462
|
+
var cof$2 = _cof;
|
|
39463
|
+
var _iobject = Object("z").propertyIsEnumerable(0) ? Object : function(it) {
|
|
39464
|
+
return cof$2(it) == "String" ? it.split("") : Object(it);
|
|
39465
|
+
};
|
|
39479
39466
|
var _defined = /* @__PURE__ */ __name(function(it) {
|
|
39480
39467
|
if (it == void 0)
|
|
39481
39468
|
throw TypeError("Can't call method on " + it);
|
|
39482
39469
|
return it;
|
|
39483
39470
|
}, "_defined");
|
|
39484
|
-
var IObject =
|
|
39471
|
+
var IObject = _iobject;
|
|
39485
39472
|
var defined$2 = _defined;
|
|
39486
39473
|
var _toIobject = /* @__PURE__ */ __name(function(it) {
|
|
39487
39474
|
return IObject(defined$2(it));
|
|
@@ -39578,15 +39565,7 @@ var _objectKeys = Object.keys || /* @__PURE__ */ __name(function keys2(O2) {
|
|
|
39578
39565
|
var _objectGops = {};
|
|
39579
39566
|
_objectGops.f = Object.getOwnPropertySymbols;
|
|
39580
39567
|
var _objectPie = {};
|
|
39581
|
-
|
|
39582
|
-
function require_objectPie() {
|
|
39583
|
-
if (hasRequired_objectPie)
|
|
39584
|
-
return _objectPie;
|
|
39585
|
-
hasRequired_objectPie = 1;
|
|
39586
|
-
_objectPie.f = {}.propertyIsEnumerable;
|
|
39587
|
-
return _objectPie;
|
|
39588
|
-
}
|
|
39589
|
-
__name(require_objectPie, "require_objectPie");
|
|
39568
|
+
_objectPie.f = {}.propertyIsEnumerable;
|
|
39590
39569
|
var defined$1 = _defined;
|
|
39591
39570
|
var _toObject = /* @__PURE__ */ __name(function(it) {
|
|
39592
39571
|
return Object(defined$1(it));
|
|
@@ -39600,9 +39579,9 @@ function require_objectAssign() {
|
|
|
39600
39579
|
var DESCRIPTORS2 = _descriptors;
|
|
39601
39580
|
var getKeys2 = _objectKeys;
|
|
39602
39581
|
var gOPS2 = _objectGops;
|
|
39603
|
-
var pIE2 =
|
|
39582
|
+
var pIE2 = _objectPie;
|
|
39604
39583
|
var toObject2 = _toObject;
|
|
39605
|
-
var IObject2 =
|
|
39584
|
+
var IObject2 = _iobject;
|
|
39606
39585
|
var $assign = Object.assign;
|
|
39607
39586
|
_objectAssign = !$assign || _fails(function() {
|
|
39608
39587
|
var A2 = {};
|
|
@@ -40237,7 +40216,7 @@ var _wksDefine = /* @__PURE__ */ __name(function(name2) {
|
|
|
40237
40216
|
}, "_wksDefine");
|
|
40238
40217
|
var getKeys = _objectKeys;
|
|
40239
40218
|
var gOPS$1 = _objectGops;
|
|
40240
|
-
var pIE$1 =
|
|
40219
|
+
var pIE$1 = _objectPie;
|
|
40241
40220
|
var _enumKeys = /* @__PURE__ */ __name(function(it) {
|
|
40242
40221
|
var result = getKeys(it);
|
|
40243
40222
|
var getSymbols2 = gOPS$1.f;
|
|
@@ -40278,7 +40257,7 @@ _objectGopnExt.f = /* @__PURE__ */ __name(function getOwnPropertyNames2(it) {
|
|
|
40278
40257
|
return windowNames && toString$3.call(it) == "[object Window]" ? getWindowNames(it) : gOPN$1(toIObject$2(it));
|
|
40279
40258
|
}, "getOwnPropertyNames");
|
|
40280
40259
|
var _objectGopd = {};
|
|
40281
|
-
var pIE =
|
|
40260
|
+
var pIE = _objectPie;
|
|
40282
40261
|
var createDesc$1 = _propertyDesc;
|
|
40283
40262
|
var toIObject$1 = _toIobject;
|
|
40284
40263
|
var toPrimitive$1 = _toPrimitive$1;
|
|
@@ -40458,7 +40437,7 @@ if (!USE_NATIVE) {
|
|
|
40458
40437
|
$GOPD.f = $getOwnPropertyDescriptor;
|
|
40459
40438
|
$DP.f = $defineProperty;
|
|
40460
40439
|
_objectGopn.f = gOPNExt.f = $getOwnPropertyNames;
|
|
40461
|
-
|
|
40440
|
+
_objectPie.f = $propertyIsEnumerable;
|
|
40462
40441
|
$GOPS.f = $getOwnPropertySymbols;
|
|
40463
40442
|
if (DESCRIPTORS && !_library) {
|
|
40464
40443
|
redefine(ObjectProto, "propertyIsEnumerable", $propertyIsEnumerable);
|
|
@@ -120189,6 +120168,9 @@ function genbankToJson(string2, options = {}) {
|
|
|
120189
120168
|
options.isProtein = false;
|
|
120190
120169
|
}
|
|
120191
120170
|
options.sequenceTypeFromLocus = item;
|
|
120171
|
+
if (item.match(/ss-dna/i)) {
|
|
120172
|
+
options.isSingleStrandedDNA = true;
|
|
120173
|
+
}
|
|
120192
120174
|
}
|
|
120193
120175
|
if (typeof lineArr[j] === "string" && gbDivisions[lineArr[j].toUpperCase()]) {
|
|
120194
120176
|
gbDivision = lineArr[j].toUpperCase();
|
|
@@ -120199,6 +120181,7 @@ function genbankToJson(string2, options = {}) {
|
|
|
120199
120181
|
}
|
|
120200
120182
|
result.parsedSequence.gbDivision = gbDivision;
|
|
120201
120183
|
result.parsedSequence.sequenceTypeFromLocus = options.sequenceTypeFromLocus;
|
|
120184
|
+
result.parsedSequence.isSingleStrandedDNA = options.isSingleStrandedDNA;
|
|
120202
120185
|
result.parsedSequence.date = date;
|
|
120203
120186
|
result.parsedSequence.circular = circular2;
|
|
120204
120187
|
}
|
|
@@ -132219,6 +132202,7 @@ function jsonToGenbank(_serSeq, options) {
|
|
|
132219
132202
|
}
|
|
132220
132203
|
__name(jsonToGenbank, "jsonToGenbank");
|
|
132221
132204
|
function createGenbankLocus(serSeq, options) {
|
|
132205
|
+
var _a2;
|
|
132222
132206
|
if (serSeq.sequence.symbols) {
|
|
132223
132207
|
serSeq.sequence = serSeq.sequence.symbols.split("");
|
|
132224
132208
|
}
|
|
@@ -132229,7 +132213,7 @@ function createGenbankLocus(serSeq, options) {
|
|
|
132229
132213
|
} else if (serSeq.type === "RNA") {
|
|
132230
132214
|
dnaType = "RNA";
|
|
132231
132215
|
} else {
|
|
132232
|
-
dnaType = "DNA";
|
|
132216
|
+
dnaType = (_a2 = serSeq == null ? void 0 : serSeq.sequenceTypeFromLocus) != null ? _a2 : "DNA";
|
|
132233
132217
|
}
|
|
132234
132218
|
const date = getCurrentDateString();
|
|
132235
132219
|
let line = StringUtil.rpad("LOCUS", " ", 12);
|
|
@@ -135769,6 +135753,7 @@ function showAddOrEditAnnotationDialog({
|
|
|
135769
135753
|
}
|
|
135770
135754
|
__name(showAddOrEditAnnotationDialog, "showAddOrEditAnnotationDialog");
|
|
135771
135755
|
function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, { convertAnnotationsFromAAIndices } = {}) {
|
|
135756
|
+
var _a2;
|
|
135772
135757
|
const {
|
|
135773
135758
|
sequenceData: sequenceData2,
|
|
135774
135759
|
annotationVisibility: annotationVisibility2,
|
|
@@ -135780,7 +135765,9 @@ function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, {
|
|
|
135780
135765
|
const isAlreadyProteinEditor = currentEditor.sequenceData && currentEditor.sequenceData.isProtein;
|
|
135781
135766
|
const isAlreadyRnaEditor = currentEditor.sequenceData && currentEditor.sequenceData.isRna;
|
|
135782
135767
|
const isAlreadyOligoEditor = currentEditor.sequenceData && currentEditor.sequenceData.isOligo;
|
|
135783
|
-
const
|
|
135768
|
+
const reverseSequenceShouldBeUpdate = ((_a2 = currentEditor.sequenceData) == null ? void 0 : _a2.isSingleStrandedDNA) !== (sequenceData2 == null ? void 0 : sequenceData2.isSingleStrandedDNA);
|
|
135769
|
+
const annotationVisibilityUpdated = !lodashExports.isEqual(annotationVisibility2, currentEditor.annotationVisibility) || !lodashExports.isEqual(annotationsToSupport2, currentEditor.annotationsToSupport);
|
|
135770
|
+
const isAlreadySpecialEditor = isAlreadyProteinEditor || isAlreadyRnaEditor || isAlreadyOligoEditor || reverseSequenceShouldBeUpdate || annotationVisibilityUpdated;
|
|
135784
135771
|
let toSpread = {};
|
|
135785
135772
|
let payload;
|
|
135786
135773
|
if (justPassingPartialSeqData) {
|
|
@@ -135886,7 +135873,7 @@ function updateEditor(store2, editorName, initialValues2 = {}, extraMeta = {}, {
|
|
|
135886
135873
|
}, annotationVisibility2), {
|
|
135887
135874
|
//we spread this here to allow the user to override this .. if they must!
|
|
135888
135875
|
sequence: true,
|
|
135889
|
-
reverseSequence:
|
|
135876
|
+
reverseSequence: !(sequenceData2 == null ? void 0 : sequenceData2.isSingleStrandedDNA),
|
|
135890
135877
|
translations: false,
|
|
135891
135878
|
aminoAcidNumbers: false,
|
|
135892
135879
|
primaryProteinSequence: false
|
|
@@ -137220,7 +137207,12 @@ const getDevMessage = /* @__PURE__ */ __name((message) => clean$2(`
|
|
|
137220
137207
|
|
|
137221
137208
|
%c👷 This is a development only message. It will be removed in production builds.
|
|
137222
137209
|
`), "getDevMessage");
|
|
137223
|
-
const getFormattedMessage = /* @__PURE__ */ __name((message) => [
|
|
137210
|
+
const getFormattedMessage = /* @__PURE__ */ __name((message) => [
|
|
137211
|
+
getDevMessage(message),
|
|
137212
|
+
"color: #00C584; font-size: 1.2em; font-weight: bold;",
|
|
137213
|
+
"line-height: 1.5",
|
|
137214
|
+
"color: #723874;"
|
|
137215
|
+
], "getFormattedMessage");
|
|
137224
137216
|
const isDisabledFlag = "__@hello-pangea/dnd-disable-dev-warnings";
|
|
137225
137217
|
function log$2(type2, message) {
|
|
137226
137218
|
if (isProduction$1) {
|
|
@@ -138046,7 +138038,11 @@ const goAfter = /* @__PURE__ */ __name((_ref) => {
|
|
|
138046
138038
|
moveRelativeTo,
|
|
138047
138039
|
isMoving
|
|
138048
138040
|
} = _ref;
|
|
138049
|
-
return patch(
|
|
138041
|
+
return patch(
|
|
138042
|
+
axis.line,
|
|
138043
|
+
moveRelativeTo.marginBox[axis.end] + distanceFromStartToBorderBoxCenter(axis, isMoving),
|
|
138044
|
+
getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving)
|
|
138045
|
+
);
|
|
138050
138046
|
}, "goAfter");
|
|
138051
138047
|
const goBefore = /* @__PURE__ */ __name((_ref2) => {
|
|
138052
138048
|
let {
|
|
@@ -138054,7 +138050,11 @@ const goBefore = /* @__PURE__ */ __name((_ref2) => {
|
|
|
138054
138050
|
moveRelativeTo,
|
|
138055
138051
|
isMoving
|
|
138056
138052
|
} = _ref2;
|
|
138057
|
-
return patch(
|
|
138053
|
+
return patch(
|
|
138054
|
+
axis.line,
|
|
138055
|
+
moveRelativeTo.marginBox[axis.start] - distanceFromEndToBorderBoxCenter(axis, isMoving),
|
|
138056
|
+
getCrossAxisBorderBoxCenter(axis, moveRelativeTo.marginBox, isMoving)
|
|
138057
|
+
);
|
|
138058
138058
|
}, "goBefore");
|
|
138059
138059
|
const goIntoStart = /* @__PURE__ */ __name((_ref3) => {
|
|
138060
138060
|
let {
|
|
@@ -138231,7 +138231,11 @@ var speculativelyIncrease = /* @__PURE__ */ __name((_ref) => {
|
|
|
138231
138231
|
});
|
|
138232
138232
|
const invisible = {};
|
|
138233
138233
|
const visible = {};
|
|
138234
|
-
const groups = [
|
|
138234
|
+
const groups = [
|
|
138235
|
+
last2,
|
|
138236
|
+
withViewportScroll,
|
|
138237
|
+
withDroppableScroll2
|
|
138238
|
+
];
|
|
138235
138239
|
last2.all.forEach((id2) => {
|
|
138236
138240
|
const displacement = tryGetVisible(id2, groups);
|
|
138237
138241
|
if (displacement) {
|
|
@@ -138588,7 +138592,9 @@ var moveToNewDroppable = /* @__PURE__ */ __name((_ref) => {
|
|
|
138588
138592
|
});
|
|
138589
138593
|
return isVisibleInNewLocation ? proposed : null;
|
|
138590
138594
|
}
|
|
138591
|
-
const isGoingBeforeTarget = Boolean(
|
|
138595
|
+
const isGoingBeforeTarget = Boolean(
|
|
138596
|
+
previousPageBorderBoxCenter[destination.axis.line] <= moveRelativeTo.page.borderBox.center[destination.axis.line]
|
|
138597
|
+
);
|
|
138592
138598
|
const proposedIndex = (() => {
|
|
138593
138599
|
const relativeTo = moveRelativeTo.descriptor.index;
|
|
138594
138600
|
if (moveRelativeTo.descriptor.id === draggable2.descriptor.id) {
|
|
@@ -138751,7 +138757,11 @@ function getFurthestAway(_ref) {
|
|
|
138751
138757
|
const startCenter = draggable2.page.borderBox.center;
|
|
138752
138758
|
const sorted = candidates.map((candidate) => {
|
|
138753
138759
|
const axis = candidate.axis;
|
|
138754
|
-
const target = patch(
|
|
138760
|
+
const target = patch(
|
|
138761
|
+
candidate.axis.line,
|
|
138762
|
+
pageBorderBox.center[axis.line],
|
|
138763
|
+
candidate.page.borderBox.center[axis.crossAxisLine]
|
|
138764
|
+
);
|
|
138755
138765
|
return {
|
|
138756
138766
|
id: candidate.descriptor.id,
|
|
138757
138767
|
distance: distance$1(startCenter, target)
|
|
@@ -140486,7 +140496,19 @@ var createStore$1 = /* @__PURE__ */ __name((_ref) => {
|
|
|
140486
140496
|
announce,
|
|
140487
140497
|
autoScroller
|
|
140488
140498
|
} = _ref;
|
|
140489
|
-
return createStore$2(reducer, composeEnhancers(applyMiddleware(
|
|
140499
|
+
return createStore$2(reducer, composeEnhancers(applyMiddleware(
|
|
140500
|
+
style$n(styleMarshal),
|
|
140501
|
+
dimensionMarshalStopper(dimensionMarshal),
|
|
140502
|
+
lift(dimensionMarshal),
|
|
140503
|
+
drop,
|
|
140504
|
+
dropAnimationFinish,
|
|
140505
|
+
dropAnimationFlushOnScroll,
|
|
140506
|
+
pendingDrop$1,
|
|
140507
|
+
autoScroll(autoScroller),
|
|
140508
|
+
scrollListener$1,
|
|
140509
|
+
focus2(focusMarshal),
|
|
140510
|
+
responders(getResponders, announce)
|
|
140511
|
+
)));
|
|
140490
140512
|
}, "createStore$1");
|
|
140491
140513
|
const clean$1 = /* @__PURE__ */ __name(() => ({
|
|
140492
140514
|
additions: {},
|
|
@@ -140513,7 +140535,9 @@ function createPublisher(_ref) {
|
|
|
140513
140535
|
removals,
|
|
140514
140536
|
modified: modified2
|
|
140515
140537
|
} = staging;
|
|
140516
|
-
const added2 = Object.keys(additions).map(
|
|
140538
|
+
const added2 = Object.keys(additions).map(
|
|
140539
|
+
(id2) => registry.draggable.getById(id2).getDimension(origin)
|
|
140540
|
+
).sort((a2, b3) => a2.descriptor.index - b3.descriptor.index);
|
|
140517
140541
|
const updated = Object.keys(modified2).map((id2) => {
|
|
140518
140542
|
const entry = registry.droppable.getById(id2);
|
|
140519
140543
|
const scroll2 = entry.callbacks.getScrollWhileDragging();
|
|
@@ -140572,13 +140596,16 @@ var getMaxScroll = /* @__PURE__ */ __name((_ref) => {
|
|
|
140572
140596
|
height: height2,
|
|
140573
140597
|
width
|
|
140574
140598
|
} = _ref;
|
|
140575
|
-
const maxScroll = subtract(
|
|
140576
|
-
|
|
140577
|
-
|
|
140578
|
-
|
|
140579
|
-
|
|
140580
|
-
|
|
140581
|
-
|
|
140599
|
+
const maxScroll = subtract(
|
|
140600
|
+
{
|
|
140601
|
+
x: scrollWidth,
|
|
140602
|
+
y: scrollHeight
|
|
140603
|
+
},
|
|
140604
|
+
{
|
|
140605
|
+
x: width,
|
|
140606
|
+
y: height2
|
|
140607
|
+
}
|
|
140608
|
+
);
|
|
140582
140609
|
const adjustedMaxScroll = {
|
|
140583
140610
|
x: Math.max(0, maxScroll.x),
|
|
140584
140611
|
y: Math.max(0, maxScroll.y)
|
|
@@ -141495,11 +141522,14 @@ function useStyleMarshal(contextId, nonce) {
|
|
|
141495
141522
|
const styles2 = useMemo(() => getStyles$1(contextId), [contextId]);
|
|
141496
141523
|
const alwaysRef = React$3.useRef(null);
|
|
141497
141524
|
const dynamicRef = React$3.useRef(null);
|
|
141498
|
-
const setDynamicStyle = useCallback(
|
|
141499
|
-
|
|
141500
|
-
|
|
141501
|
-
|
|
141502
|
-
|
|
141525
|
+
const setDynamicStyle = useCallback(
|
|
141526
|
+
memoizeOne((proposed) => {
|
|
141527
|
+
const el = dynamicRef.current;
|
|
141528
|
+
!el ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot set dynamic style element if it is not set") : invariant$1(false) : void 0;
|
|
141529
|
+
el.textContent = proposed;
|
|
141530
|
+
}),
|
|
141531
|
+
[]
|
|
141532
|
+
);
|
|
141503
141533
|
const setAlwaysStyle = useCallback((proposed) => {
|
|
141504
141534
|
const el = alwaysRef.current;
|
|
141505
141535
|
!el ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot set dynamic style element if it is not set") : invariant$1(false) : void 0;
|
|
@@ -141555,8 +141585,8 @@ function querySelectorAll(parentNode, selector) {
|
|
|
141555
141585
|
}
|
|
141556
141586
|
__name(querySelectorAll, "querySelectorAll");
|
|
141557
141587
|
var getWindowFromEl = /* @__PURE__ */ __name((el) => {
|
|
141558
|
-
var
|
|
141559
|
-
return (
|
|
141588
|
+
var _el$ownerDocument;
|
|
141589
|
+
return (el == null ? void 0 : (_el$ownerDocument = el.ownerDocument) == null ? void 0 : _el$ownerDocument.defaultView) || window;
|
|
141560
141590
|
}, "getWindowFromEl");
|
|
141561
141591
|
function isHtmlElement(el) {
|
|
141562
141592
|
return el instanceof getWindowFromEl(el).HTMLElement;
|
|
@@ -142117,141 +142147,157 @@ function getCaptureBindings(_ref) {
|
|
|
142117
142147
|
getPhase,
|
|
142118
142148
|
setPhase
|
|
142119
142149
|
} = _ref;
|
|
142120
|
-
return [
|
|
142121
|
-
|
|
142122
|
-
|
|
142123
|
-
|
|
142124
|
-
|
|
142125
|
-
|
|
142126
|
-
|
|
142127
|
-
|
|
142128
|
-
|
|
142129
|
-
|
|
142130
|
-
|
|
142131
|
-
|
|
142132
|
-
|
|
142133
|
-
|
|
142134
|
-
|
|
142135
|
-
|
|
142136
|
-
|
|
142150
|
+
return [
|
|
142151
|
+
{
|
|
142152
|
+
eventName: "mousemove",
|
|
142153
|
+
fn: (event) => {
|
|
142154
|
+
const {
|
|
142155
|
+
button,
|
|
142156
|
+
clientX,
|
|
142157
|
+
clientY
|
|
142158
|
+
} = event;
|
|
142159
|
+
if (button !== primaryButton) {
|
|
142160
|
+
return;
|
|
142161
|
+
}
|
|
142162
|
+
const point2 = {
|
|
142163
|
+
x: clientX,
|
|
142164
|
+
y: clientY
|
|
142165
|
+
};
|
|
142166
|
+
const phase = getPhase();
|
|
142167
|
+
if (phase.type === "DRAGGING") {
|
|
142168
|
+
event.preventDefault();
|
|
142169
|
+
phase.actions.move(point2);
|
|
142170
|
+
return;
|
|
142171
|
+
}
|
|
142172
|
+
!(phase.type === "PENDING") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot be IDLE") : invariant$1(false) : void 0;
|
|
142173
|
+
const pending = phase.point;
|
|
142174
|
+
if (!isSloppyClickThresholdExceeded(pending, point2)) {
|
|
142175
|
+
return;
|
|
142176
|
+
}
|
|
142137
142177
|
event.preventDefault();
|
|
142138
|
-
phase.actions.
|
|
142139
|
-
|
|
142140
|
-
|
|
142141
|
-
|
|
142142
|
-
|
|
142143
|
-
if (!isSloppyClickThresholdExceeded(pending, point2)) {
|
|
142144
|
-
return;
|
|
142145
|
-
}
|
|
142146
|
-
event.preventDefault();
|
|
142147
|
-
const actions2 = phase.actions.fluidLift(point2);
|
|
142148
|
-
setPhase({
|
|
142149
|
-
type: "DRAGGING",
|
|
142150
|
-
actions: actions2
|
|
142151
|
-
});
|
|
142152
|
-
}
|
|
142153
|
-
}, {
|
|
142154
|
-
eventName: "mouseup",
|
|
142155
|
-
fn: (event) => {
|
|
142156
|
-
const phase = getPhase();
|
|
142157
|
-
if (phase.type !== "DRAGGING") {
|
|
142158
|
-
cancel();
|
|
142159
|
-
return;
|
|
142178
|
+
const actions2 = phase.actions.fluidLift(point2);
|
|
142179
|
+
setPhase({
|
|
142180
|
+
type: "DRAGGING",
|
|
142181
|
+
actions: actions2
|
|
142182
|
+
});
|
|
142160
142183
|
}
|
|
142161
|
-
|
|
142162
|
-
|
|
142163
|
-
|
|
142164
|
-
|
|
142165
|
-
|
|
142166
|
-
|
|
142167
|
-
|
|
142168
|
-
|
|
142169
|
-
|
|
142170
|
-
if (getPhase().type === "DRAGGING") {
|
|
142184
|
+
},
|
|
142185
|
+
{
|
|
142186
|
+
eventName: "mouseup",
|
|
142187
|
+
fn: (event) => {
|
|
142188
|
+
const phase = getPhase();
|
|
142189
|
+
if (phase.type !== "DRAGGING") {
|
|
142190
|
+
cancel();
|
|
142191
|
+
return;
|
|
142192
|
+
}
|
|
142171
142193
|
event.preventDefault();
|
|
142194
|
+
phase.actions.drop({
|
|
142195
|
+
shouldBlockNextClick: true
|
|
142196
|
+
});
|
|
142197
|
+
completed();
|
|
142172
142198
|
}
|
|
142173
|
-
|
|
142174
|
-
|
|
142175
|
-
|
|
142176
|
-
|
|
142177
|
-
|
|
142178
|
-
|
|
142179
|
-
|
|
142199
|
+
},
|
|
142200
|
+
{
|
|
142201
|
+
eventName: "mousedown",
|
|
142202
|
+
fn: (event) => {
|
|
142203
|
+
if (getPhase().type === "DRAGGING") {
|
|
142204
|
+
event.preventDefault();
|
|
142205
|
+
}
|
|
142180
142206
|
cancel();
|
|
142181
|
-
return;
|
|
142182
142207
|
}
|
|
142183
|
-
|
|
142184
|
-
|
|
142185
|
-
|
|
142186
|
-
|
|
142208
|
+
},
|
|
142209
|
+
{
|
|
142210
|
+
eventName: "keydown",
|
|
142211
|
+
fn: (event) => {
|
|
142212
|
+
const phase = getPhase();
|
|
142213
|
+
if (phase.type === "PENDING") {
|
|
142214
|
+
cancel();
|
|
142215
|
+
return;
|
|
142216
|
+
}
|
|
142217
|
+
if (event.keyCode === escape$1) {
|
|
142218
|
+
event.preventDefault();
|
|
142219
|
+
cancel();
|
|
142220
|
+
return;
|
|
142221
|
+
}
|
|
142222
|
+
preventStandardKeyEvents(event);
|
|
142187
142223
|
}
|
|
142188
|
-
preventStandardKeyEvents(event);
|
|
142189
|
-
}
|
|
142190
|
-
}, {
|
|
142191
|
-
eventName: "resize",
|
|
142192
|
-
fn: cancel
|
|
142193
|
-
}, {
|
|
142194
|
-
eventName: "scroll",
|
|
142195
|
-
options: {
|
|
142196
|
-
passive: true,
|
|
142197
|
-
capture: false
|
|
142198
142224
|
},
|
|
142199
|
-
|
|
142200
|
-
|
|
142201
|
-
|
|
142225
|
+
{
|
|
142226
|
+
eventName: "resize",
|
|
142227
|
+
fn: cancel
|
|
142228
|
+
},
|
|
142229
|
+
{
|
|
142230
|
+
eventName: "scroll",
|
|
142231
|
+
options: {
|
|
142232
|
+
passive: true,
|
|
142233
|
+
capture: false
|
|
142234
|
+
},
|
|
142235
|
+
fn: () => {
|
|
142236
|
+
if (getPhase().type === "PENDING") {
|
|
142237
|
+
cancel();
|
|
142238
|
+
}
|
|
142202
142239
|
}
|
|
142203
|
-
}
|
|
142204
|
-
|
|
142205
|
-
|
|
142206
|
-
|
|
142207
|
-
|
|
142208
|
-
|
|
142209
|
-
|
|
142210
|
-
|
|
142211
|
-
|
|
142240
|
+
},
|
|
142241
|
+
{
|
|
142242
|
+
eventName: "webkitmouseforcedown",
|
|
142243
|
+
fn: (event) => {
|
|
142244
|
+
const phase = getPhase();
|
|
142245
|
+
!(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Unexpected phase") : invariant$1(false) : void 0;
|
|
142246
|
+
if (phase.actions.shouldRespectForcePress()) {
|
|
142247
|
+
cancel();
|
|
142248
|
+
return;
|
|
142249
|
+
}
|
|
142250
|
+
event.preventDefault();
|
|
142212
142251
|
}
|
|
142213
|
-
|
|
142252
|
+
},
|
|
142253
|
+
{
|
|
142254
|
+
eventName: supportedPageVisibilityEventName,
|
|
142255
|
+
fn: cancel
|
|
142214
142256
|
}
|
|
142215
|
-
|
|
142216
|
-
eventName: supportedPageVisibilityEventName,
|
|
142217
|
-
fn: cancel
|
|
142218
|
-
}];
|
|
142257
|
+
];
|
|
142219
142258
|
}
|
|
142220
142259
|
__name(getCaptureBindings, "getCaptureBindings");
|
|
142221
142260
|
function useMouseSensor(api) {
|
|
142222
142261
|
const phaseRef = React$3.useRef(idle$1);
|
|
142223
142262
|
const unbindEventsRef = React$3.useRef(noop$2);
|
|
142224
|
-
const startCaptureBinding = useMemo(
|
|
142225
|
-
|
|
142226
|
-
|
|
142227
|
-
|
|
142228
|
-
|
|
142229
|
-
|
|
142230
|
-
|
|
142231
|
-
|
|
142232
|
-
|
|
142233
|
-
|
|
142234
|
-
|
|
142235
|
-
|
|
142236
|
-
|
|
142237
|
-
|
|
142238
|
-
|
|
142239
|
-
|
|
142240
|
-
|
|
142241
|
-
|
|
142242
|
-
|
|
142243
|
-
|
|
142244
|
-
|
|
142245
|
-
|
|
142246
|
-
|
|
142247
|
-
|
|
142248
|
-
|
|
142249
|
-
|
|
142250
|
-
|
|
142251
|
-
|
|
142252
|
-
|
|
142253
|
-
|
|
142254
|
-
|
|
142263
|
+
const startCaptureBinding = useMemo(
|
|
142264
|
+
() => ({
|
|
142265
|
+
eventName: "mousedown",
|
|
142266
|
+
fn: /* @__PURE__ */ __name(function onMouseDown3(event) {
|
|
142267
|
+
if (event.defaultPrevented) {
|
|
142268
|
+
return;
|
|
142269
|
+
}
|
|
142270
|
+
if (event.button !== primaryButton) {
|
|
142271
|
+
return;
|
|
142272
|
+
}
|
|
142273
|
+
if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) {
|
|
142274
|
+
return;
|
|
142275
|
+
}
|
|
142276
|
+
const draggableId = api.findClosestDraggableId(event);
|
|
142277
|
+
if (!draggableId) {
|
|
142278
|
+
return;
|
|
142279
|
+
}
|
|
142280
|
+
const actions2 = api.tryGetLock(
|
|
142281
|
+
draggableId,
|
|
142282
|
+
stop,
|
|
142283
|
+
{
|
|
142284
|
+
sourceEvent: event
|
|
142285
|
+
}
|
|
142286
|
+
);
|
|
142287
|
+
if (!actions2) {
|
|
142288
|
+
return;
|
|
142289
|
+
}
|
|
142290
|
+
event.preventDefault();
|
|
142291
|
+
const point2 = {
|
|
142292
|
+
x: event.clientX,
|
|
142293
|
+
y: event.clientY
|
|
142294
|
+
};
|
|
142295
|
+
unbindEventsRef.current();
|
|
142296
|
+
startPendingDrag(actions2, point2);
|
|
142297
|
+
}, "onMouseDown")
|
|
142298
|
+
}),
|
|
142299
|
+
[api]
|
|
142300
|
+
);
|
|
142255
142301
|
const preventForcePressBinding = useMemo(() => ({
|
|
142256
142302
|
eventName: "webkitmouseforcewillbegin",
|
|
142257
142303
|
fn: (event) => {
|
|
@@ -142355,110 +142401,126 @@ function getDraggingBindings(actions2, stop) {
|
|
|
142355
142401
|
actions2.drop();
|
|
142356
142402
|
}
|
|
142357
142403
|
__name(drop2, "drop");
|
|
142358
|
-
return [
|
|
142359
|
-
|
|
142360
|
-
|
|
142361
|
-
|
|
142362
|
-
event.
|
|
142363
|
-
|
|
142364
|
-
|
|
142365
|
-
|
|
142366
|
-
|
|
142367
|
-
event.
|
|
142368
|
-
|
|
142369
|
-
|
|
142370
|
-
|
|
142371
|
-
|
|
142372
|
-
event.
|
|
142373
|
-
|
|
142374
|
-
|
|
142375
|
-
|
|
142376
|
-
|
|
142377
|
-
event.
|
|
142378
|
-
|
|
142379
|
-
|
|
142380
|
-
|
|
142381
|
-
|
|
142382
|
-
event.
|
|
142383
|
-
|
|
142384
|
-
|
|
142385
|
-
|
|
142386
|
-
|
|
142387
|
-
event.
|
|
142388
|
-
|
|
142389
|
-
|
|
142404
|
+
return [
|
|
142405
|
+
{
|
|
142406
|
+
eventName: "keydown",
|
|
142407
|
+
fn: (event) => {
|
|
142408
|
+
if (event.keyCode === escape$1) {
|
|
142409
|
+
event.preventDefault();
|
|
142410
|
+
cancel();
|
|
142411
|
+
return;
|
|
142412
|
+
}
|
|
142413
|
+
if (event.keyCode === space) {
|
|
142414
|
+
event.preventDefault();
|
|
142415
|
+
drop2();
|
|
142416
|
+
return;
|
|
142417
|
+
}
|
|
142418
|
+
if (event.keyCode === arrowDown) {
|
|
142419
|
+
event.preventDefault();
|
|
142420
|
+
actions2.moveDown();
|
|
142421
|
+
return;
|
|
142422
|
+
}
|
|
142423
|
+
if (event.keyCode === arrowUp) {
|
|
142424
|
+
event.preventDefault();
|
|
142425
|
+
actions2.moveUp();
|
|
142426
|
+
return;
|
|
142427
|
+
}
|
|
142428
|
+
if (event.keyCode === arrowRight) {
|
|
142429
|
+
event.preventDefault();
|
|
142430
|
+
actions2.moveRight();
|
|
142431
|
+
return;
|
|
142432
|
+
}
|
|
142433
|
+
if (event.keyCode === arrowLeft) {
|
|
142434
|
+
event.preventDefault();
|
|
142435
|
+
actions2.moveLeft();
|
|
142436
|
+
return;
|
|
142437
|
+
}
|
|
142438
|
+
if (scrollJumpKeys[event.keyCode]) {
|
|
142439
|
+
event.preventDefault();
|
|
142440
|
+
return;
|
|
142441
|
+
}
|
|
142442
|
+
preventStandardKeyEvents(event);
|
|
142390
142443
|
}
|
|
142391
|
-
|
|
142392
|
-
|
|
142393
|
-
|
|
142444
|
+
},
|
|
142445
|
+
{
|
|
142446
|
+
eventName: "mousedown",
|
|
142447
|
+
fn: cancel
|
|
142448
|
+
},
|
|
142449
|
+
{
|
|
142450
|
+
eventName: "mouseup",
|
|
142451
|
+
fn: cancel
|
|
142452
|
+
},
|
|
142453
|
+
{
|
|
142454
|
+
eventName: "click",
|
|
142455
|
+
fn: cancel
|
|
142456
|
+
},
|
|
142457
|
+
{
|
|
142458
|
+
eventName: "touchstart",
|
|
142459
|
+
fn: cancel
|
|
142460
|
+
},
|
|
142461
|
+
{
|
|
142462
|
+
eventName: "resize",
|
|
142463
|
+
fn: cancel
|
|
142464
|
+
},
|
|
142465
|
+
{
|
|
142466
|
+
eventName: "wheel",
|
|
142467
|
+
fn: cancel,
|
|
142468
|
+
options: {
|
|
142469
|
+
passive: true
|
|
142394
142470
|
}
|
|
142395
|
-
|
|
142396
|
-
|
|
142397
|
-
|
|
142398
|
-
|
|
142399
|
-
fn: cancel
|
|
142400
|
-
}, {
|
|
142401
|
-
eventName: "mouseup",
|
|
142402
|
-
fn: cancel
|
|
142403
|
-
}, {
|
|
142404
|
-
eventName: "click",
|
|
142405
|
-
fn: cancel
|
|
142406
|
-
}, {
|
|
142407
|
-
eventName: "touchstart",
|
|
142408
|
-
fn: cancel
|
|
142409
|
-
}, {
|
|
142410
|
-
eventName: "resize",
|
|
142411
|
-
fn: cancel
|
|
142412
|
-
}, {
|
|
142413
|
-
eventName: "wheel",
|
|
142414
|
-
fn: cancel,
|
|
142415
|
-
options: {
|
|
142416
|
-
passive: true
|
|
142471
|
+
},
|
|
142472
|
+
{
|
|
142473
|
+
eventName: supportedPageVisibilityEventName,
|
|
142474
|
+
fn: cancel
|
|
142417
142475
|
}
|
|
142418
|
-
|
|
142419
|
-
eventName: supportedPageVisibilityEventName,
|
|
142420
|
-
fn: cancel
|
|
142421
|
-
}];
|
|
142476
|
+
];
|
|
142422
142477
|
}
|
|
142423
142478
|
__name(getDraggingBindings, "getDraggingBindings");
|
|
142424
142479
|
function useKeyboardSensor(api) {
|
|
142425
142480
|
const unbindEventsRef = React$3.useRef(noop$1$1);
|
|
142426
|
-
const startCaptureBinding = useMemo(
|
|
142427
|
-
|
|
142428
|
-
|
|
142429
|
-
|
|
142430
|
-
|
|
142431
|
-
|
|
142432
|
-
|
|
142433
|
-
|
|
142434
|
-
|
|
142435
|
-
|
|
142436
|
-
|
|
142437
|
-
|
|
142438
|
-
|
|
142439
|
-
|
|
142440
|
-
|
|
142441
|
-
|
|
142442
|
-
|
|
142443
|
-
|
|
142444
|
-
|
|
142445
|
-
|
|
142446
|
-
|
|
142447
|
-
|
|
142448
|
-
|
|
142449
|
-
|
|
142450
|
-
|
|
142451
|
-
isCapturing =
|
|
142481
|
+
const startCaptureBinding = useMemo(
|
|
142482
|
+
() => ({
|
|
142483
|
+
eventName: "keydown",
|
|
142484
|
+
fn: /* @__PURE__ */ __name(function onKeyDown(event) {
|
|
142485
|
+
if (event.defaultPrevented) {
|
|
142486
|
+
return;
|
|
142487
|
+
}
|
|
142488
|
+
if (event.keyCode !== space) {
|
|
142489
|
+
return;
|
|
142490
|
+
}
|
|
142491
|
+
const draggableId = api.findClosestDraggableId(event);
|
|
142492
|
+
if (!draggableId) {
|
|
142493
|
+
return;
|
|
142494
|
+
}
|
|
142495
|
+
const preDrag = api.tryGetLock(
|
|
142496
|
+
draggableId,
|
|
142497
|
+
stop,
|
|
142498
|
+
{
|
|
142499
|
+
sourceEvent: event
|
|
142500
|
+
}
|
|
142501
|
+
);
|
|
142502
|
+
if (!preDrag) {
|
|
142503
|
+
return;
|
|
142504
|
+
}
|
|
142505
|
+
event.preventDefault();
|
|
142506
|
+
let isCapturing = true;
|
|
142507
|
+
const actions2 = preDrag.snapLift();
|
|
142452
142508
|
unbindEventsRef.current();
|
|
142453
|
-
|
|
142454
|
-
|
|
142455
|
-
|
|
142456
|
-
|
|
142457
|
-
|
|
142458
|
-
|
|
142459
|
-
|
|
142460
|
-
|
|
142461
|
-
|
|
142509
|
+
function stop() {
|
|
142510
|
+
!isCapturing ? process.env.NODE_ENV !== "production" ? invariant$1(false, "Cannot stop capturing a keyboard drag when not capturing") : invariant$1(false) : void 0;
|
|
142511
|
+
isCapturing = false;
|
|
142512
|
+
unbindEventsRef.current();
|
|
142513
|
+
listenForCapture();
|
|
142514
|
+
}
|
|
142515
|
+
__name(stop, "stop");
|
|
142516
|
+
unbindEventsRef.current = bindEvents(window, getDraggingBindings(actions2, stop), {
|
|
142517
|
+
capture: true,
|
|
142518
|
+
passive: false
|
|
142519
|
+
});
|
|
142520
|
+
}, "onKeyDown")
|
|
142521
|
+
}),
|
|
142522
|
+
[api]
|
|
142523
|
+
);
|
|
142462
142524
|
const listenForCapture = useCallback(/* @__PURE__ */ __name(function tryStartCapture() {
|
|
142463
142525
|
const options = {
|
|
142464
142526
|
passive: false,
|
|
@@ -142484,33 +142546,39 @@ function getWindowBindings(_ref) {
|
|
|
142484
142546
|
cancel,
|
|
142485
142547
|
getPhase
|
|
142486
142548
|
} = _ref;
|
|
142487
|
-
return [
|
|
142488
|
-
|
|
142489
|
-
|
|
142490
|
-
|
|
142491
|
-
|
|
142492
|
-
|
|
142493
|
-
|
|
142494
|
-
|
|
142495
|
-
|
|
142496
|
-
|
|
142497
|
-
|
|
142498
|
-
|
|
142499
|
-
eventName: "keydown",
|
|
142500
|
-
fn: (event) => {
|
|
142501
|
-
if (getPhase().type !== "DRAGGING") {
|
|
142502
|
-
cancel();
|
|
142503
|
-
return;
|
|
142504
|
-
}
|
|
142505
|
-
if (event.keyCode === escape$1) {
|
|
142549
|
+
return [
|
|
142550
|
+
{
|
|
142551
|
+
eventName: "orientationchange",
|
|
142552
|
+
fn: cancel
|
|
142553
|
+
},
|
|
142554
|
+
{
|
|
142555
|
+
eventName: "resize",
|
|
142556
|
+
fn: cancel
|
|
142557
|
+
},
|
|
142558
|
+
{
|
|
142559
|
+
eventName: "contextmenu",
|
|
142560
|
+
fn: (event) => {
|
|
142506
142561
|
event.preventDefault();
|
|
142507
142562
|
}
|
|
142508
|
-
|
|
142563
|
+
},
|
|
142564
|
+
{
|
|
142565
|
+
eventName: "keydown",
|
|
142566
|
+
fn: (event) => {
|
|
142567
|
+
if (getPhase().type !== "DRAGGING") {
|
|
142568
|
+
cancel();
|
|
142569
|
+
return;
|
|
142570
|
+
}
|
|
142571
|
+
if (event.keyCode === escape$1) {
|
|
142572
|
+
event.preventDefault();
|
|
142573
|
+
}
|
|
142574
|
+
cancel();
|
|
142575
|
+
}
|
|
142576
|
+
},
|
|
142577
|
+
{
|
|
142578
|
+
eventName: supportedPageVisibilityEventName,
|
|
142579
|
+
fn: cancel
|
|
142509
142580
|
}
|
|
142510
|
-
|
|
142511
|
-
eventName: supportedPageVisibilityEventName,
|
|
142512
|
-
fn: cancel
|
|
142513
|
-
}];
|
|
142581
|
+
];
|
|
142514
142582
|
}
|
|
142515
142583
|
__name(getWindowBindings, "getWindowBindings");
|
|
142516
142584
|
function getHandleBindings(_ref2) {
|
|
@@ -142519,87 +142587,93 @@ function getHandleBindings(_ref2) {
|
|
|
142519
142587
|
completed,
|
|
142520
142588
|
getPhase
|
|
142521
142589
|
} = _ref2;
|
|
142522
|
-
return [
|
|
142523
|
-
|
|
142524
|
-
|
|
142525
|
-
|
|
142526
|
-
|
|
142527
|
-
|
|
142528
|
-
|
|
142529
|
-
|
|
142530
|
-
|
|
142531
|
-
|
|
142590
|
+
return [
|
|
142591
|
+
{
|
|
142592
|
+
eventName: "touchmove",
|
|
142593
|
+
options: {
|
|
142594
|
+
capture: false
|
|
142595
|
+
},
|
|
142596
|
+
fn: (event) => {
|
|
142597
|
+
const phase = getPhase();
|
|
142598
|
+
if (phase.type !== "DRAGGING") {
|
|
142599
|
+
cancel();
|
|
142600
|
+
return;
|
|
142601
|
+
}
|
|
142602
|
+
phase.hasMoved = true;
|
|
142603
|
+
const {
|
|
142604
|
+
clientX,
|
|
142605
|
+
clientY
|
|
142606
|
+
} = event.touches[0];
|
|
142607
|
+
const point2 = {
|
|
142608
|
+
x: clientX,
|
|
142609
|
+
y: clientY
|
|
142610
|
+
};
|
|
142611
|
+
event.preventDefault();
|
|
142612
|
+
phase.actions.move(point2);
|
|
142532
142613
|
}
|
|
142533
|
-
|
|
142534
|
-
|
|
142535
|
-
|
|
142536
|
-
|
|
142537
|
-
|
|
142538
|
-
|
|
142539
|
-
|
|
142540
|
-
|
|
142541
|
-
|
|
142542
|
-
|
|
142543
|
-
|
|
142544
|
-
|
|
142545
|
-
|
|
142546
|
-
|
|
142547
|
-
fn: (event) => {
|
|
142548
|
-
const phase = getPhase();
|
|
142549
|
-
if (phase.type !== "DRAGGING") {
|
|
142550
|
-
cancel();
|
|
142551
|
-
return;
|
|
142614
|
+
},
|
|
142615
|
+
{
|
|
142616
|
+
eventName: "touchend",
|
|
142617
|
+
fn: (event) => {
|
|
142618
|
+
const phase = getPhase();
|
|
142619
|
+
if (phase.type !== "DRAGGING") {
|
|
142620
|
+
cancel();
|
|
142621
|
+
return;
|
|
142622
|
+
}
|
|
142623
|
+
event.preventDefault();
|
|
142624
|
+
phase.actions.drop({
|
|
142625
|
+
shouldBlockNextClick: true
|
|
142626
|
+
});
|
|
142627
|
+
completed();
|
|
142552
142628
|
}
|
|
142553
|
-
|
|
142554
|
-
|
|
142555
|
-
|
|
142556
|
-
|
|
142557
|
-
|
|
142558
|
-
|
|
142559
|
-
|
|
142560
|
-
|
|
142561
|
-
|
|
142562
|
-
if (getPhase().type !== "DRAGGING") {
|
|
142629
|
+
},
|
|
142630
|
+
{
|
|
142631
|
+
eventName: "touchcancel",
|
|
142632
|
+
fn: (event) => {
|
|
142633
|
+
if (getPhase().type !== "DRAGGING") {
|
|
142634
|
+
cancel();
|
|
142635
|
+
return;
|
|
142636
|
+
}
|
|
142637
|
+
event.preventDefault();
|
|
142563
142638
|
cancel();
|
|
142564
|
-
return;
|
|
142565
|
-
}
|
|
142566
|
-
event.preventDefault();
|
|
142567
|
-
cancel();
|
|
142568
|
-
}
|
|
142569
|
-
}, {
|
|
142570
|
-
eventName: "touchforcechange",
|
|
142571
|
-
fn: (event) => {
|
|
142572
|
-
const phase = getPhase();
|
|
142573
|
-
!(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false) : invariant$1(false) : void 0;
|
|
142574
|
-
const touch3 = event.touches[0];
|
|
142575
|
-
if (!touch3) {
|
|
142576
|
-
return;
|
|
142577
|
-
}
|
|
142578
|
-
const isForcePress = touch3.force >= forcePressThreshold;
|
|
142579
|
-
if (!isForcePress) {
|
|
142580
|
-
return;
|
|
142581
142639
|
}
|
|
142582
|
-
|
|
142583
|
-
|
|
142640
|
+
},
|
|
142641
|
+
{
|
|
142642
|
+
eventName: "touchforcechange",
|
|
142643
|
+
fn: (event) => {
|
|
142644
|
+
const phase = getPhase();
|
|
142645
|
+
!(phase.type !== "IDLE") ? process.env.NODE_ENV !== "production" ? invariant$1(false) : invariant$1(false) : void 0;
|
|
142646
|
+
const touch3 = event.touches[0];
|
|
142647
|
+
if (!touch3) {
|
|
142648
|
+
return;
|
|
142649
|
+
}
|
|
142650
|
+
const isForcePress = touch3.force >= forcePressThreshold;
|
|
142651
|
+
if (!isForcePress) {
|
|
142652
|
+
return;
|
|
142653
|
+
}
|
|
142654
|
+
const shouldRespect = phase.actions.shouldRespectForcePress();
|
|
142655
|
+
if (phase.type === "PENDING") {
|
|
142656
|
+
if (shouldRespect) {
|
|
142657
|
+
cancel();
|
|
142658
|
+
}
|
|
142659
|
+
return;
|
|
142660
|
+
}
|
|
142584
142661
|
if (shouldRespect) {
|
|
142662
|
+
if (phase.hasMoved) {
|
|
142663
|
+
event.preventDefault();
|
|
142664
|
+
return;
|
|
142665
|
+
}
|
|
142585
142666
|
cancel();
|
|
142586
|
-
}
|
|
142587
|
-
return;
|
|
142588
|
-
}
|
|
142589
|
-
if (shouldRespect) {
|
|
142590
|
-
if (phase.hasMoved) {
|
|
142591
|
-
event.preventDefault();
|
|
142592
142667
|
return;
|
|
142593
142668
|
}
|
|
142594
|
-
|
|
142595
|
-
return;
|
|
142669
|
+
event.preventDefault();
|
|
142596
142670
|
}
|
|
142597
|
-
|
|
142671
|
+
},
|
|
142672
|
+
{
|
|
142673
|
+
eventName: supportedPageVisibilityEventName,
|
|
142674
|
+
fn: cancel
|
|
142598
142675
|
}
|
|
142599
|
-
|
|
142600
|
-
eventName: supportedPageVisibilityEventName,
|
|
142601
|
-
fn: cancel
|
|
142602
|
-
}];
|
|
142676
|
+
];
|
|
142603
142677
|
}
|
|
142604
142678
|
__name(getHandleBindings, "getHandleBindings");
|
|
142605
142679
|
function useTouchSensor(api) {
|
|
@@ -142611,35 +142685,42 @@ function useTouchSensor(api) {
|
|
|
142611
142685
|
const setPhase = useCallback(/* @__PURE__ */ __name(function setPhase2(phase) {
|
|
142612
142686
|
phaseRef.current = phase;
|
|
142613
142687
|
}, "setPhase"), []);
|
|
142614
|
-
const startCaptureBinding = useMemo(
|
|
142615
|
-
|
|
142616
|
-
|
|
142617
|
-
|
|
142618
|
-
|
|
142619
|
-
|
|
142620
|
-
|
|
142621
|
-
|
|
142622
|
-
|
|
142623
|
-
|
|
142624
|
-
|
|
142625
|
-
|
|
142626
|
-
|
|
142627
|
-
|
|
142628
|
-
|
|
142629
|
-
|
|
142630
|
-
|
|
142631
|
-
|
|
142632
|
-
|
|
142633
|
-
|
|
142634
|
-
|
|
142635
|
-
|
|
142636
|
-
|
|
142637
|
-
|
|
142638
|
-
|
|
142639
|
-
|
|
142640
|
-
|
|
142641
|
-
|
|
142642
|
-
|
|
142688
|
+
const startCaptureBinding = useMemo(
|
|
142689
|
+
() => ({
|
|
142690
|
+
eventName: "touchstart",
|
|
142691
|
+
fn: /* @__PURE__ */ __name(function onTouchStart(event) {
|
|
142692
|
+
if (event.defaultPrevented) {
|
|
142693
|
+
return;
|
|
142694
|
+
}
|
|
142695
|
+
const draggableId = api.findClosestDraggableId(event);
|
|
142696
|
+
if (!draggableId) {
|
|
142697
|
+
return;
|
|
142698
|
+
}
|
|
142699
|
+
const actions2 = api.tryGetLock(
|
|
142700
|
+
draggableId,
|
|
142701
|
+
stop,
|
|
142702
|
+
{
|
|
142703
|
+
sourceEvent: event
|
|
142704
|
+
}
|
|
142705
|
+
);
|
|
142706
|
+
if (!actions2) {
|
|
142707
|
+
return;
|
|
142708
|
+
}
|
|
142709
|
+
const touch3 = event.touches[0];
|
|
142710
|
+
const {
|
|
142711
|
+
clientX,
|
|
142712
|
+
clientY
|
|
142713
|
+
} = touch3;
|
|
142714
|
+
const point2 = {
|
|
142715
|
+
x: clientX,
|
|
142716
|
+
y: clientY
|
|
142717
|
+
};
|
|
142718
|
+
unbindEventsRef.current();
|
|
142719
|
+
startPendingDrag(actions2, point2);
|
|
142720
|
+
}, "onTouchStart")
|
|
142721
|
+
}),
|
|
142722
|
+
[api]
|
|
142723
|
+
);
|
|
142643
142724
|
const listenForCapture = useCallback(/* @__PURE__ */ __name(function listenForCapture2() {
|
|
142644
142725
|
const options = {
|
|
142645
142726
|
capture: true,
|
|
@@ -143822,10 +143903,15 @@ const makeMapStateToProps$1 = /* @__PURE__ */ __name(() => {
|
|
|
143822
143903
|
const mapDispatchToProps$1 = {
|
|
143823
143904
|
dropAnimationFinished
|
|
143824
143905
|
};
|
|
143825
|
-
const ConnectedDraggable = connect(
|
|
143826
|
-
|
|
143827
|
-
|
|
143828
|
-
|
|
143906
|
+
const ConnectedDraggable = connect(
|
|
143907
|
+
makeMapStateToProps$1,
|
|
143908
|
+
mapDispatchToProps$1,
|
|
143909
|
+
null,
|
|
143910
|
+
{
|
|
143911
|
+
context: StoreContext,
|
|
143912
|
+
areStatePropsEqual: isStrictEqual
|
|
143913
|
+
}
|
|
143914
|
+
)(Draggable$1$1);
|
|
143829
143915
|
var ConnectedDraggable$1 = ConnectedDraggable;
|
|
143830
143916
|
function PrivateDraggable(props) {
|
|
143831
143917
|
const droppableContext = useRequiredContext(DroppableContext);
|
|
@@ -144180,7 +144266,11 @@ function useDroppablePublisher(args) {
|
|
|
144180
144266
|
}
|
|
144181
144267
|
scheduleScrollUpdate.cancel();
|
|
144182
144268
|
closest2.removeAttribute(scrollContainer.contextId);
|
|
144183
|
-
closest2.removeEventListener(
|
|
144269
|
+
closest2.removeEventListener(
|
|
144270
|
+
"scroll",
|
|
144271
|
+
onClosestScroll,
|
|
144272
|
+
getListenerOptions(dragging.scrollOptions)
|
|
144273
|
+
);
|
|
144184
144274
|
}, [onClosestScroll, scheduleScrollUpdate]);
|
|
144185
144275
|
const scroll2 = useCallback((change3) => {
|
|
144186
144276
|
const dragging = whileDraggingRef.current;
|
|
@@ -144579,33 +144669,6 @@ const Droppable = /* @__PURE__ */ __name((props) => {
|
|
|
144579
144669
|
}, children(provided, snapshot), getClone());
|
|
144580
144670
|
}, "Droppable");
|
|
144581
144671
|
var Droppable$1 = Droppable;
|
|
144582
|
-
function getBody() {
|
|
144583
|
-
!document.body ? process.env.NODE_ENV !== "production" ? invariant$1(false, "document.body is not ready") : invariant$1(false) : void 0;
|
|
144584
|
-
return document.body;
|
|
144585
|
-
}
|
|
144586
|
-
__name(getBody, "getBody");
|
|
144587
|
-
const defaultProps = {
|
|
144588
|
-
mode: "standard",
|
|
144589
|
-
type: "DEFAULT",
|
|
144590
|
-
direction: "vertical",
|
|
144591
|
-
isDropDisabled: false,
|
|
144592
|
-
isCombineEnabled: false,
|
|
144593
|
-
ignoreContainerClipping: false,
|
|
144594
|
-
renderClone: null,
|
|
144595
|
-
getContainerForClone: getBody
|
|
144596
|
-
};
|
|
144597
|
-
const attachDefaultPropsToOwnProps = /* @__PURE__ */ __name((ownProps) => {
|
|
144598
|
-
let mergedProps = __spreadValues({}, ownProps);
|
|
144599
|
-
let defaultPropKey;
|
|
144600
|
-
for (defaultPropKey in defaultProps) {
|
|
144601
|
-
if (ownProps[defaultPropKey] === void 0) {
|
|
144602
|
-
mergedProps = __spreadProps(__spreadValues({}, mergedProps), {
|
|
144603
|
-
[defaultPropKey]: defaultProps[defaultPropKey]
|
|
144604
|
-
});
|
|
144605
|
-
}
|
|
144606
|
-
}
|
|
144607
|
-
return mergedProps;
|
|
144608
|
-
}, "attachDefaultPropsToOwnProps");
|
|
144609
144672
|
const isMatchingType = /* @__PURE__ */ __name((type2, critical) => type2 === critical.droppable.type, "isMatchingType");
|
|
144610
144673
|
const getDraggable = /* @__PURE__ */ __name((critical, dimensions) => dimensions.draggables[critical.draggable.id], "getDraggable");
|
|
144611
144674
|
const makeMapStateToProps = /* @__PURE__ */ __name(() => {
|
|
@@ -144672,11 +144735,10 @@ const makeMapStateToProps = /* @__PURE__ */ __name(() => {
|
|
|
144672
144735
|
};
|
|
144673
144736
|
});
|
|
144674
144737
|
const selector = /* @__PURE__ */ __name((state2, ownProps) => {
|
|
144675
|
-
const
|
|
144676
|
-
const
|
|
144677
|
-
const
|
|
144678
|
-
const
|
|
144679
|
-
const renderClone = ownPropsWithDefaultProps.renderClone;
|
|
144738
|
+
const id2 = ownProps.droppableId;
|
|
144739
|
+
const type2 = ownProps.type;
|
|
144740
|
+
const isEnabled = !ownProps.isDropDisabled;
|
|
144741
|
+
const renderClone = ownProps.renderClone;
|
|
144680
144742
|
if (isDragging(state2)) {
|
|
144681
144743
|
const critical = state2.critical;
|
|
144682
144744
|
if (!isMatchingType(type2, critical)) {
|
|
@@ -144717,12 +144779,31 @@ const makeMapStateToProps = /* @__PURE__ */ __name(() => {
|
|
|
144717
144779
|
const mapDispatchToProps = {
|
|
144718
144780
|
updateViewportMaxScroll
|
|
144719
144781
|
};
|
|
144720
|
-
|
|
144721
|
-
|
|
144722
|
-
|
|
144723
|
-
|
|
144724
|
-
|
|
144725
|
-
|
|
144782
|
+
function getBody() {
|
|
144783
|
+
!document.body ? process.env.NODE_ENV !== "production" ? invariant$1(false, "document.body is not ready") : invariant$1(false) : void 0;
|
|
144784
|
+
return document.body;
|
|
144785
|
+
}
|
|
144786
|
+
__name(getBody, "getBody");
|
|
144787
|
+
const defaultProps = {
|
|
144788
|
+
mode: "standard",
|
|
144789
|
+
type: "DEFAULT",
|
|
144790
|
+
direction: "vertical",
|
|
144791
|
+
isDropDisabled: false,
|
|
144792
|
+
isCombineEnabled: false,
|
|
144793
|
+
ignoreContainerClipping: false,
|
|
144794
|
+
renderClone: null,
|
|
144795
|
+
getContainerForClone: getBody
|
|
144796
|
+
};
|
|
144797
|
+
const ConnectedDroppable = connect(
|
|
144798
|
+
makeMapStateToProps,
|
|
144799
|
+
mapDispatchToProps,
|
|
144800
|
+
null,
|
|
144801
|
+
{
|
|
144802
|
+
context: StoreContext,
|
|
144803
|
+
areStatePropsEqual: isStrictEqual
|
|
144804
|
+
}
|
|
144805
|
+
)(Droppable$1);
|
|
144806
|
+
ConnectedDroppable.defaultProps = defaultProps;
|
|
144726
144807
|
var ConnectedDroppable$1 = ConnectedDroppable;
|
|
144727
144808
|
var clipboard = { exports: {} };
|
|
144728
144809
|
/*!
|
|
@@ -153126,7 +153207,7 @@ function showFileDialog({ multiple = false, onSelect }) {
|
|
|
153126
153207
|
}
|
|
153127
153208
|
__name(showFileDialog, "showFileDialog");
|
|
153128
153209
|
const name = "@teselagen/ove";
|
|
153129
|
-
const version = "0.0.
|
|
153210
|
+
const version = "0.0.4";
|
|
153130
153211
|
const main = "./index.js";
|
|
153131
153212
|
const types$1 = "./index.d.ts";
|
|
153132
153213
|
const type = "commonjs";
|
|
@@ -173420,6 +173501,10 @@ class GenbankView extends React$3.Component {
|
|
|
173420
173501
|
__publicField(this, "state", {
|
|
173421
173502
|
fileTypeToView: "genbank"
|
|
173422
173503
|
});
|
|
173504
|
+
__publicField(this, "select", /* @__PURE__ */ __name(() => {
|
|
173505
|
+
var _a2;
|
|
173506
|
+
return (_a2 = this._input) == null ? void 0 : _a2.select();
|
|
173507
|
+
}, "select"));
|
|
173423
173508
|
}
|
|
173424
173509
|
render() {
|
|
173425
173510
|
const { sequenceData: sequenceData2 = {} } = this.props;
|
|
@@ -173457,7 +173542,7 @@ class GenbankView extends React$3.Component {
|
|
|
173457
173542
|
{
|
|
173458
173543
|
"data-test": "ve-genbank-text",
|
|
173459
173544
|
readOnly: true,
|
|
173460
|
-
|
|
173545
|
+
onClick: this.select,
|
|
173461
173546
|
style: {
|
|
173462
173547
|
whiteSpace: "pre",
|
|
173463
173548
|
overflowWrap: "normal",
|