382 lines
12 KiB
JavaScript
382 lines
12 KiB
JavaScript
// Module ID: 7106
|
|
// Function ID: 7107
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: [7088, 7089, 7107, 7109, 7110, 7112, 7114]
|
|
|
|
// Module 7106 (_isNativeReflectConstruct)
|
|
import _inheritsDefault from "_inherits" /* 7112 */;
|
|
import RVMasonryLayoutManagerImpl from "_classCallCheck" /* 7088 */;
|
|
import closure_1 from "_possibleConstructorReturn" /* 7107 */;
|
|
import closure_2 from "_getPrototypeOf" /* 7109 */;
|
|
import closure_3 from "_get" /* 7110 */;
|
|
import importDefaultResult from "_createClass" /* 7089 */;
|
|
|
|
function _isNativeReflectConstruct() {
|
|
try {
|
|
const _Boolean = Boolean;
|
|
const call = valueOf.call;
|
|
const _Reflect = Reflect;
|
|
const _Boolean2 = Boolean;
|
|
if (typeof call === "unknown") {
|
|
let callResult = valueOf();
|
|
} else {
|
|
callResult = call(constructResult);
|
|
}
|
|
closure_0 = !callResult;
|
|
_isNativeReflectConstruct = function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
};
|
|
return _isNativeReflectConstruct();
|
|
} catch (err) {
|
|
}
|
|
}
|
|
class RVMasonryLayoutManagerImpl {
|
|
constructor(arg0, arg1) {
|
|
self = this;
|
|
tmp = RVMasonryLayoutManagerImpl(this, RVMasonryLayoutManagerImpl);
|
|
items = [, ];
|
|
items[0] = global;
|
|
items[1] = arg1;
|
|
tmp2 = closure_2;
|
|
obj = closure_2(RVMasonryLayoutManagerImpl);
|
|
tmp3 = closure_1;
|
|
if (_isNativeReflectConstruct()) {
|
|
tmp5 = globalThis;
|
|
_Reflect = Reflect;
|
|
constructResult = Reflect.construct(obj, items, tmp2(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items);
|
|
}
|
|
tmp3Result = tmp3(self, constructResult);
|
|
tmp3Result.currentColumn = 0;
|
|
tmp3Result.fullRelayoutRequired = false;
|
|
tmp3Result.boundedSize = global.windowSize.width;
|
|
tmp3Result.optimizeItemArrangement = global.optimizeItemArrangement;
|
|
columnHeights = tmp3Result.columnHeights;
|
|
if (columnHeights == null) {
|
|
tmp7 = globalThis;
|
|
_Array = Array;
|
|
ArrayResult = Array(tmp3Result.maxColumns);
|
|
columnHeights = require("module_0");
|
|
}
|
|
tmp3Result.columnHeights = columnHeights;
|
|
return tmp3Result;
|
|
}
|
|
}
|
|
_inheritsDefault(RVMasonryLayoutManagerImpl, require("RVLayoutManager").RVLayoutManager);
|
|
let items = [
|
|
{
|
|
key: "updateLayoutParams",
|
|
value: function updateLayoutParams(windowSize) {
|
|
let self = this;
|
|
self = this;
|
|
closure_1 = undefined;
|
|
({ maxColumns, optimizeItemArrangement } = this);
|
|
const tmp = callback2(callback(self.prototype), "updateLayoutParams", this);
|
|
closure_1 = tmp;
|
|
let fn = tmp;
|
|
if (typeof tmp === "function") {
|
|
fn = (items) => callback.apply(self, items);
|
|
}
|
|
const items = [windowSize];
|
|
!fn(items);
|
|
if (!tmp3) {
|
|
self.boundedSize = windowSize.windowSize.width;
|
|
if (self.layouts.length > 0) {
|
|
self.updateAllWidths();
|
|
self.recomputeLayouts(0, self.layouts.length - 1);
|
|
self.requiresRepaint = true;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "processLayoutInfo",
|
|
value: function processLayoutInfo(arg0, arg1) {
|
|
const self = this;
|
|
const iter = arg0[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let index = nextResult.index;
|
|
let tmp2 = self.layouts[index];
|
|
tmp2.height = nextResult.dimensions.height;
|
|
tmp2.isHeightMeasured = true;
|
|
tmp2.isWidthMeasured = true;
|
|
self.layouts[index] = tmp2;
|
|
continue;
|
|
}
|
|
if (self.fullRelayoutRequired) {
|
|
self.updateAllWidths();
|
|
self.fullRelayoutRequired = false;
|
|
return 0;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "estimateLayout",
|
|
value: function estimateLayout(arg0) {
|
|
this.layouts[arg0].width = this.getWidth(arg0);
|
|
this.layouts[arg0].height = this.getEstimatedHeight(arg0);
|
|
this.layouts[arg0].isWidthMeasured = true;
|
|
this.layouts[arg0].enforcedWidth = true;
|
|
}
|
|
},
|
|
{
|
|
key: "handleSpanChange",
|
|
value: function handleSpanChange(arg0) {
|
|
this.fullRelayoutRequired = true;
|
|
}
|
|
},
|
|
{
|
|
key: "getLayoutSize",
|
|
value: function getLayoutSize() {
|
|
const self = this;
|
|
if (0 === this.layouts.length) {
|
|
return { width: 0, height: 0 };
|
|
} else {
|
|
const _Math = Math;
|
|
const items = [];
|
|
HermesBuiltin.arraySpread(self.columnHeights, 0);
|
|
const _Math2 = Math;
|
|
const obj = { width: null, height: null };
|
|
obj[0] = self.boundedSize;
|
|
obj[1] = HermesBuiltin.apply(items, Math);
|
|
return obj;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "recomputeLayouts",
|
|
value: function recomputeLayouts(sum) {
|
|
const self = this;
|
|
if (0 === sum) {
|
|
const _Array = Array;
|
|
self.columnHeights = Array(self.maxColumns).fill(0);
|
|
self.currentColumn = 0;
|
|
const ArrayResult = Array(self.maxColumns);
|
|
} else {
|
|
const result = self.updateColumnHeightsToIndex(sum);
|
|
}
|
|
if (sum < self.layouts.length) {
|
|
do {
|
|
let layout = self.getLayout(sum);
|
|
let span = self.getSpan(sum, true);
|
|
let tmp6 = sum;
|
|
if (self.optimizeItemArrangement) {
|
|
if (1 === span) {
|
|
let result1 = self.placeSingleColumnItem(layout);
|
|
} else {
|
|
let result2 = self.placeOptimizedMultiColumnItem(layout, span);
|
|
}
|
|
} else {
|
|
let result3 = self.placeItemSequentially(layout, span);
|
|
}
|
|
sum = sum + 1;
|
|
} while (sum < length);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "getWidth",
|
|
value: function getWidth(sum) {
|
|
const result = this.boundedSize / this.maxColumns;
|
|
return result * this.getSpan(sum);
|
|
}
|
|
},
|
|
{
|
|
key: "updateAllWidths",
|
|
value: function updateAllWidths() {
|
|
let length;
|
|
const self = this;
|
|
let num = 0;
|
|
if (0 < this.layouts.length) {
|
|
do {
|
|
self.layouts[num].width = self.getWidth(num);
|
|
self.layouts[num].minHeight = undefined;
|
|
num = num + 1;
|
|
length = self.layouts.length;
|
|
} while (num < length);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "placeItemSequentially",
|
|
value: function placeItemSequentially(layout, span) {
|
|
const self = this;
|
|
if (this.currentColumn + span > this.maxColumns) {
|
|
self.currentColumn = 0;
|
|
}
|
|
let tmp = self.columnHeights[self.currentColumn];
|
|
let sum = self.currentColumn + 1;
|
|
let tmp3 = tmp;
|
|
if (sum < self.currentColumn + span) {
|
|
do {
|
|
let tmp4 = sum;
|
|
let tmp5 = tmp;
|
|
let bound = tmp;
|
|
if (sum < self.maxColumns) {
|
|
let _Math = Math;
|
|
bound = Math.max(tmp, self.columnHeights[sum]);
|
|
}
|
|
sum = sum + 1;
|
|
tmp = bound;
|
|
tmp3 = bound;
|
|
} while (sum < self.currentColumn + span);
|
|
}
|
|
layout.x = self.boundedSize / self.maxColumns * self.currentColumn;
|
|
layout.y = tmp3;
|
|
let currentColumn = self.currentColumn;
|
|
if (currentColumn < self.currentColumn + span) {
|
|
do {
|
|
let tmp7 = currentColumn;
|
|
if (currentColumn < self.maxColumns) {
|
|
self.columnHeights[currentColumn] = tmp3 + layout.height;
|
|
}
|
|
currentColumn = currentColumn + 1;
|
|
} while (currentColumn < self.currentColumn + span);
|
|
}
|
|
self.currentColumn = self.currentColumn + span;
|
|
if (self.currentColumn >= self.maxColumns) {
|
|
self.currentColumn = 0;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "placeSingleColumnItem",
|
|
value: function placeSingleColumnItem(layout) {
|
|
const self = this;
|
|
let first = this.columnHeights[0];
|
|
let num = 0;
|
|
let num2 = 1;
|
|
let num3 = 0;
|
|
if (1 < this.maxColumns) {
|
|
do {
|
|
let tmp2 = num2;
|
|
let tmp3 = first;
|
|
let tmp4 = num;
|
|
if (self.columnHeights[num2] < first) {
|
|
tmp3 = self.columnHeights[num2];
|
|
tmp4 = num2;
|
|
}
|
|
num2 = num2 + 1;
|
|
first = tmp3;
|
|
num = tmp4;
|
|
num3 = tmp4;
|
|
} while (num2 < self.maxColumns);
|
|
}
|
|
layout.x = self.boundedSize / self.maxColumns * num3;
|
|
layout.y = self.columnHeights[num3];
|
|
const columnHeights = self.columnHeights;
|
|
columnHeights[num3] = columnHeights[num3] + layout.height;
|
|
}
|
|
},
|
|
{
|
|
key: "placeOptimizedMultiColumnItem",
|
|
value: function placeOptimizedMultiColumnItem(layout, span) {
|
|
let sum;
|
|
let sum5;
|
|
const self = this;
|
|
let num = 0;
|
|
let num2 = 0;
|
|
let num3 = 0;
|
|
if (0 <= this.maxColumns - span) {
|
|
do {
|
|
let bound = self.columnHeights[num];
|
|
sum = num + 1;
|
|
let tmp3 = num;
|
|
let tmp4 = MAX_VALUE;
|
|
let tmp5 = num2;
|
|
let tmp6 = bound;
|
|
let sum1 = sum;
|
|
if (sum < num + span) {
|
|
do {
|
|
let _Math = Math;
|
|
bound = Math.max(bound, self.columnHeights[sum1]);
|
|
sum1 = sum1 + 1;
|
|
tmp6 = bound;
|
|
sum2 = num + span;
|
|
} while (sum1 < sum2);
|
|
}
|
|
let num4 = 0;
|
|
let num5 = 0;
|
|
let num6 = 0;
|
|
if (0 < self.maxColumns) {
|
|
while (true) {
|
|
let tmp9 = num4;
|
|
let tmp10 = num5;
|
|
if (num <= num4) {
|
|
if (num4 < num + span) {
|
|
let sum3 = tmp6 + layout.height;
|
|
num5 = num5 + sum3;
|
|
num4 = num4 + 1;
|
|
num6 = num5;
|
|
if (num4 >= self.maxColumns) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
sum3 = self.columnHeights[num4];
|
|
}
|
|
}
|
|
if (num6 < tmp4) {
|
|
tmp4 = num6;
|
|
tmp5 = num;
|
|
}
|
|
MAX_VALUE = tmp4;
|
|
num2 = tmp5;
|
|
num = sum;
|
|
num3 = tmp5;
|
|
} while (sum <= self.maxColumns - span);
|
|
}
|
|
const columnHeights = self.columnHeights;
|
|
const items = [...columnHeights.slice(num3, num3 + span)];
|
|
const applyResult = Math.max.apply(items);
|
|
layout.x = self.boundedSize / self.maxColumns * num3;
|
|
layout.y = applyResult;
|
|
let sum4 = num3;
|
|
if (num3 < num3 + span) {
|
|
do {
|
|
self.columnHeights[sum4] = applyResult + layout.height;
|
|
sum4 = sum4 + 1;
|
|
sum5 = num3 + span;
|
|
} while (sum4 < sum5);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "updateColumnHeightsToIndex",
|
|
value: function updateColumnHeightsToIndex(sum) {
|
|
const self = this;
|
|
let num = 0;
|
|
this.columnHeights = Array(this.maxColumns).fill(0);
|
|
this.currentColumn = 0;
|
|
if (0 < sum) {
|
|
do {
|
|
let size = self.layouts[num];
|
|
let result = self.boundedSize / self.maxColumns;
|
|
let _Math = Math;
|
|
let rounded = Math.round(size.width / result);
|
|
let _Math2 = Math;
|
|
let rounded1 = Math.round(size.x / result);
|
|
let _Math3 = Math;
|
|
let bound = Math.min(rounded1 + rounded, self.maxColumns);
|
|
let tmp5 = num;
|
|
sum = rounded1;
|
|
if (rounded1 < bound) {
|
|
do {
|
|
let _Math4 = Math;
|
|
self.columnHeights[sum] = Math.max(self.columnHeights[sum], size.y + size.height);
|
|
sum = sum + 1;
|
|
} while (sum < bound);
|
|
}
|
|
if (!self.optimizeItemArrangement) {
|
|
self.currentColumn = (rounded1 + rounded) % self.maxColumns;
|
|
}
|
|
num = num + 1;
|
|
} while (num < sum);
|
|
}
|
|
}
|
|
}
|
|
];
|
|
|
|
export const RVMasonryLayoutManagerImpl = importDefaultResult(RVMasonryLayoutManagerImpl, items);
|