mol_data_all 1.1.967 → 1.1.968

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.
Files changed (5) hide show
  1. package/node.test.js +41 -33
  2. package/node.test.js.map +1 -1
  3. package/package.json +1 -1
  4. package/web.test.js +41 -33
  5. package/web.test.js.map +1 -1
package/node.test.js CHANGED
@@ -1200,7 +1200,12 @@ var $;
1200
1200
  var $;
1201
1201
  (function ($) {
1202
1202
  function $mol_range2(item = index => index, size = () => Number.POSITIVE_INFINITY) {
1203
- return new Proxy(new $mol_range2_array(), {
1203
+ const source = typeof item === 'function' ? new $mol_range2_array() : item;
1204
+ if (typeof item !== 'function') {
1205
+ item = index => source[index];
1206
+ size = () => source.length;
1207
+ }
1208
+ return new Proxy(source, {
1204
1209
  get(target, field) {
1205
1210
  if (typeof field === 'string') {
1206
1211
  if (field === 'length')
@@ -1213,7 +1218,7 @@ var $;
1213
1218
  if (index === Math.trunc(index))
1214
1219
  return item(index);
1215
1220
  }
1216
- return target[field];
1221
+ return $mol_range2_array.prototype[field];
1217
1222
  },
1218
1223
  set(target, field) {
1219
1224
  return $mol_fail(new TypeError(`Lazy range is read only (trying to set field ${JSON.stringify(field)})`));
@@ -1254,13 +1259,16 @@ var $;
1254
1259
  return $mol_range2(index => index < this.length ? this[index] : tail[0][index - this.length], () => this.length + tail[0].length);
1255
1260
  }
1256
1261
  filter(check, context) {
1257
- const filtered = new $mol_range2_array();
1258
- for (let index = 0; index < this.length; ++index) {
1259
- const item = this[index];
1260
- if (check.call(context, item, index, this))
1261
- filtered.push(item);
1262
- }
1263
- return filtered;
1262
+ const filtered = [];
1263
+ let cursor = -1;
1264
+ return $mol_range2(index => {
1265
+ while (cursor < this.length && index >= filtered.length - 1) {
1266
+ const val = this[++cursor];
1267
+ if (check(val, cursor, this))
1268
+ filtered.push(val);
1269
+ }
1270
+ return filtered[index];
1271
+ }, () => cursor < this.length ? Number.POSITIVE_INFINITY : filtered.length);
1264
1272
  }
1265
1273
  forEach(proceed, context) {
1266
1274
  for (let [key, value] of this.entries())
@@ -1320,7 +1328,7 @@ var $;
1320
1328
  'lazy calls'() {
1321
1329
  let calls = 0;
1322
1330
  const list = $mol_range2(index => (++calls, index), () => 10);
1323
- $mol_assert_ok(list instanceof Array);
1331
+ $mol_assert_equal(true, list instanceof Array);
1324
1332
  $mol_assert_equal(list.length, 10);
1325
1333
  $mol_assert_equal(list[-1], undefined);
1326
1334
  $mol_assert_equal(list[0], 0);
@@ -1363,11 +1371,17 @@ var $;
1363
1371
  $mol_range2(i => i, () => 5).forEach(i => log += i);
1364
1372
  $mol_assert_equal(log, '01234');
1365
1373
  },
1374
+ 'reduce'() {
1375
+ let calls = 0;
1376
+ const list = $mol_range2().slice(1, 6);
1377
+ $mol_assert_equal(list.reduce((s, v) => s + v), 15);
1378
+ $mol_assert_equal(list.reduce((s, v) => s + v, 5), 20);
1379
+ },
1366
1380
  'lazy concat'() {
1367
1381
  let calls1 = 0;
1368
1382
  let calls2 = 0;
1369
1383
  const list = $mol_range2(index => (++calls1, index), () => 5).concat([0, 1, 2, 3, 4], $mol_range2(index => (++calls2, index), () => 5));
1370
- $mol_assert_ok(list instanceof Array);
1384
+ $mol_assert_equal(true, list instanceof Array);
1371
1385
  $mol_assert_equal(list.length, 15);
1372
1386
  $mol_assert_equal(list[0], 0);
1373
1387
  $mol_assert_equal(list[4], 4);
@@ -1379,32 +1393,26 @@ var $;
1379
1393
  $mol_assert_equal(calls1, 2);
1380
1394
  $mol_assert_equal(calls2, 2);
1381
1395
  },
1382
- 'filter'() {
1396
+ 'lazy filter'() {
1383
1397
  let calls = 0;
1384
- const list = $mol_range2(index => (++calls, index), () => 10).filter(v => v % 2).slice(0, 3);
1385
- $mol_assert_ok(list instanceof Array);
1398
+ const list = $mol_range2(index => (++calls, index), () => 15).filter(v => v % 2).slice(0, 3);
1399
+ $mol_assert_equal(true, list instanceof Array);
1386
1400
  $mol_assert_equal(list.length, 3);
1387
1401
  $mol_assert_equal(list[0], 1);
1388
1402
  $mol_assert_equal(list[2], 5);
1389
1403
  $mol_assert_equal(list[3], undefined);
1390
- $mol_assert_equal(calls, 10);
1404
+ $mol_assert_equal(calls, 8);
1391
1405
  },
1392
- 'reverse'() {
1406
+ 'lazy reverse'() {
1393
1407
  let calls = 0;
1394
1408
  const list = $mol_range2(index => (++calls, index), () => 10).toReversed().slice(0, 3);
1395
- $mol_assert_ok(list instanceof Array);
1409
+ $mol_assert_equal(true, list instanceof Array);
1396
1410
  $mol_assert_equal(list.length, 3);
1397
1411
  $mol_assert_equal(list[0], 9);
1398
1412
  $mol_assert_equal(list[2], 7);
1399
1413
  $mol_assert_equal(list[3], undefined);
1400
1414
  $mol_assert_equal(calls, 2);
1401
1415
  },
1402
- 'reduce'() {
1403
- let calls = 0;
1404
- const list = $mol_range2().slice(1, 6);
1405
- $mol_assert_equal(list.reduce((s, v) => s + v), 15);
1406
- $mol_assert_equal(list.reduce((s, v) => s + v, 5), 20);
1407
- },
1408
1416
  'lazy map'() {
1409
1417
  let calls1 = 0;
1410
1418
  let calls2 = 0;
@@ -1414,7 +1422,7 @@ var $;
1414
1422
  $mol_assert_equal(source, self);
1415
1423
  return index + 10;
1416
1424
  }, () => 5);
1417
- $mol_assert_ok(target instanceof Array);
1425
+ $mol_assert_equal(true, target instanceof Array);
1418
1426
  $mol_assert_equal(target.length, 5);
1419
1427
  $mol_assert_equal(target[0], 10);
1420
1428
  $mol_assert_equal(target[4], 14);
@@ -1425,7 +1433,7 @@ var $;
1425
1433
  'lazy slice'() {
1426
1434
  let calls = 0;
1427
1435
  const list = $mol_range2(index => (++calls, index), () => 10).slice(3, 7);
1428
- $mol_assert_ok(list instanceof Array);
1436
+ $mol_assert_equal(true, list instanceof Array);
1429
1437
  $mol_assert_equal(list.length, 4);
1430
1438
  $mol_assert_equal(list[0], 3);
1431
1439
  $mol_assert_equal(list[3], 6);
@@ -1434,22 +1442,22 @@ var $;
1434
1442
  },
1435
1443
  'lazy some'() {
1436
1444
  let calls = 0;
1437
- $mol_assert_ok($mol_range2(index => (++calls, index), () => 5).some(v => v >= 2));
1445
+ $mol_assert_equal(true, $mol_range2(index => (++calls, index), () => 5).some(v => v >= 2));
1438
1446
  $mol_assert_equal(calls, 3);
1439
- $mol_assert_not($mol_range2(i => i, () => 0).some(v => true));
1440
- $mol_assert_ok($mol_range2(i => i).some(v => v > 5));
1447
+ $mol_assert_equal(false, $mol_range2(i => i, () => 0).some(v => true));
1448
+ $mol_assert_equal(true, $mol_range2(i => i).some(v => v > 5));
1441
1449
  },
1442
1450
  'lazy every'() {
1443
1451
  let calls = 0;
1444
- $mol_assert_not($mol_range2(index => (++calls, index), () => 5).every(v => v < 2));
1452
+ $mol_assert_equal(false, $mol_range2(index => (++calls, index), () => 5).every(v => v < 2));
1445
1453
  $mol_assert_equal(calls, 3);
1446
- $mol_assert_ok($mol_range2(i => i, () => 0).every(v => false));
1447
- $mol_assert_not($mol_range2(i => i).every(v => v < 5));
1454
+ $mol_assert_equal(true, $mol_range2(i => i, () => 0).every(v => false));
1455
+ $mol_assert_equal(false, $mol_range2(i => i).every(v => v < 5));
1448
1456
  },
1449
1457
  'lazyfy'() {
1450
1458
  let calls = 0;
1451
- const list = new $mol_range2_array(...[0, 1, 2, 3, 4, 5]).map(i => (++calls, i + 10)).slice(2);
1452
- $mol_assert_ok(list instanceof Array);
1459
+ const list = $mol_range2([0, 1, 2, 3, 4, 5]).map(i => (++calls, i + 10)).slice(2);
1460
+ $mol_assert_equal(true, list instanceof Array);
1453
1461
  $mol_assert_equal(list.length, 4);
1454
1462
  $mol_assert_equal(calls, 0);
1455
1463
  $mol_assert_equal(list[0], 12);