serializable-bptree 9.0.3 → 9.0.4-alpha.0

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 (3) hide show
  1. package/dist/cjs/index.cjs +34 -49
  2. package/dist/esm/index.mjs +34 -49
  3. package/package.json +1 -1
package/dist/cjs/index.cjs CHANGED
@@ -2159,13 +2159,7 @@ function insertOp(ops, ctx, key, value, comparator) {
2159
2159
  }
2160
2160
  function deleteEntry(ops, ctx, node, key, comparator) {
2161
2161
  if (!node.leaf) {
2162
- let keyIndex = -1;
2163
- for (let i = 0, len = node.keys.length; i < len; i++) {
2164
- if (node.keys[i] === key) {
2165
- keyIndex = i;
2166
- break;
2167
- }
2168
- }
2162
+ let keyIndex = node.keys.indexOf(key);
2169
2163
  if (keyIndex !== -1) {
2170
2164
  node = cloneNode(node);
2171
2165
  node.keys.splice(keyIndex, 1);
@@ -2204,17 +2198,15 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2204
2198
  let nextNode = null;
2205
2199
  let prevValue = null;
2206
2200
  let postValue = null;
2207
- for (let i = 0, len = parentNode.keys.length; i < len; i++) {
2208
- const nKey = parentNode.keys[i];
2209
- if (nKey === node.id) {
2210
- if (i > 0) {
2211
- prevNode = ops.getNode(parentNode.keys[i - 1]);
2212
- prevValue = parentNode.values[i - 1];
2213
- }
2214
- if (i < parentNode.keys.length - 1) {
2215
- nextNode = ops.getNode(parentNode.keys[i + 1]);
2216
- postValue = parentNode.values[i];
2217
- }
2201
+ let keyIndex = parentNode.keys.indexOf(node.id);
2202
+ if (keyIndex !== -1) {
2203
+ if (keyIndex > 0) {
2204
+ prevNode = ops.getNode(parentNode.keys[keyIndex - 1]);
2205
+ prevValue = parentNode.values[keyIndex - 1];
2206
+ }
2207
+ if (keyIndex < parentNode.keys.length - 1) {
2208
+ nextNode = ops.getNode(parentNode.keys[keyIndex + 1]);
2209
+ postValue = parentNode.values[keyIndex];
2218
2210
  }
2219
2211
  }
2220
2212
  let siblingNode;
@@ -2247,7 +2239,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2247
2239
  siblingNode = node;
2248
2240
  node = pTemp;
2249
2241
  }
2250
- siblingNode.keys.push(...node.keys);
2242
+ siblingNode.keys = siblingNode.keys.concat(node.keys);
2251
2243
  if (!node.leaf) {
2252
2244
  siblingNode.values.push(guess);
2253
2245
  } else {
@@ -2258,7 +2250,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2258
2250
  ops.updateNode(n);
2259
2251
  }
2260
2252
  }
2261
- siblingNode.values.push(...node.values);
2253
+ siblingNode.values = siblingNode.values.concat(node.values);
2262
2254
  if (!siblingNode.leaf) {
2263
2255
  const keys = siblingNode.keys;
2264
2256
  for (let i = 0, len = keys.length; i < len; i++) {
@@ -2306,8 +2298,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2306
2298
  if (!node.leaf) {
2307
2299
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
2308
2300
  pointerK0 = siblingNode.values.splice(0, 1)[0];
2309
- node.keys = [...node.keys, pointerP0];
2310
- node.values = [...node.values, guess];
2301
+ node.keys = node.keys.concat(pointerP0);
2302
+ node.values = node.values.concat(guess);
2311
2303
  parentNode = cloneNode(ops.getNode(node.parent));
2312
2304
  const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
2313
2305
  if (pointerIndex > 0) {
@@ -2317,8 +2309,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2317
2309
  } else {
2318
2310
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
2319
2311
  pointerK0 = siblingNode.values.splice(0, 1)[0];
2320
- node.keys = [...node.keys, pointerP0];
2321
- node.values = [...node.values, pointerK0];
2312
+ node.keys = node.keys.concat(pointerP0);
2313
+ node.values = node.values.concat(pointerK0);
2322
2314
  parentNode = cloneNode(ops.getNode(node.parent));
2323
2315
  const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
2324
2316
  if (pointerIndex > 0) {
@@ -4201,13 +4193,7 @@ async function insertOpAsync(ops, ctx, key, value, comparator) {
4201
4193
  }
4202
4194
  async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4203
4195
  if (!node.leaf) {
4204
- let keyIndex = -1;
4205
- for (let i = 0, len = node.keys.length; i < len; i++) {
4206
- if (node.keys[i] === key) {
4207
- keyIndex = i;
4208
- break;
4209
- }
4210
- }
4196
+ let keyIndex = node.keys.indexOf(key);
4211
4197
  if (keyIndex !== -1) {
4212
4198
  node = cloneNode(node);
4213
4199
  node.keys.splice(keyIndex, 1);
@@ -4236,16 +4222,15 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4236
4222
  let nextNode = null;
4237
4223
  let prevValue = null;
4238
4224
  let postValue = null;
4239
- for (let i = 0, len = parentNode.keys.length; i < len; i++) {
4240
- if (parentNode.keys[i] === node.id) {
4241
- if (i > 0) {
4242
- prevNode = await ops.getNode(parentNode.keys[i - 1]);
4243
- prevValue = parentNode.values[i - 1];
4244
- }
4245
- if (i < parentNode.keys.length - 1) {
4246
- nextNode = await ops.getNode(parentNode.keys[i + 1]);
4247
- postValue = parentNode.values[i];
4248
- }
4225
+ let keyIndex = parentNode.keys.indexOf(node.id);
4226
+ if (keyIndex !== -1) {
4227
+ if (keyIndex > 0) {
4228
+ prevNode = await ops.getNode(parentNode.keys[keyIndex - 1]);
4229
+ prevValue = parentNode.values[keyIndex - 1];
4230
+ }
4231
+ if (keyIndex < parentNode.keys.length - 1) {
4232
+ nextNode = await ops.getNode(parentNode.keys[keyIndex + 1]);
4233
+ postValue = parentNode.values[keyIndex];
4249
4234
  }
4250
4235
  }
4251
4236
  let siblingNode;
@@ -4272,11 +4257,11 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4272
4257
  siblingNode = cloneNode(siblingNode);
4273
4258
  if (node.values.length + siblingNode.values.length < ctx.order) {
4274
4259
  if (!isPredecessor) {
4275
- const t = siblingNode;
4260
+ const pTemp = siblingNode;
4276
4261
  siblingNode = node;
4277
- node = t;
4262
+ node = pTemp;
4278
4263
  }
4279
- siblingNode.keys.push(...node.keys);
4264
+ siblingNode.keys = siblingNode.keys.concat(node.keys);
4280
4265
  if (!node.leaf) {
4281
4266
  siblingNode.values.push(guess);
4282
4267
  } else {
@@ -4287,7 +4272,7 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4287
4272
  await ops.updateNode(n);
4288
4273
  }
4289
4274
  }
4290
- siblingNode.values.push(...node.values);
4275
+ siblingNode.values = siblingNode.values.concat(node.values);
4291
4276
  if (!siblingNode.leaf) {
4292
4277
  for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
4293
4278
  const n = cloneNode(await ops.getNode(siblingNode.keys[i]));
@@ -4331,8 +4316,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4331
4316
  if (!node.leaf) {
4332
4317
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
4333
4318
  pointerK0 = siblingNode.values.splice(0, 1)[0];
4334
- node.keys = [...node.keys, pointerP0];
4335
- node.values = [...node.values, guess];
4319
+ node.keys = node.keys.concat(pointerP0);
4320
+ node.values = node.values.concat(guess);
4336
4321
  parentNode = cloneNode(await ops.getNode(node.parent));
4337
4322
  const pi = parentNode.keys.indexOf(siblingNode.id);
4338
4323
  if (pi > 0) {
@@ -4342,8 +4327,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4342
4327
  } else {
4343
4328
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
4344
4329
  pointerK0 = siblingNode.values.splice(0, 1)[0];
4345
- node.keys = [...node.keys, pointerP0];
4346
- node.values = [...node.values, pointerK0];
4330
+ node.keys = node.keys.concat(pointerP0);
4331
+ node.values = node.values.concat(pointerK0);
4347
4332
  parentNode = cloneNode(await ops.getNode(node.parent));
4348
4333
  const pi = parentNode.keys.indexOf(siblingNode.id);
4349
4334
  if (pi > 0) {
package/dist/esm/index.mjs CHANGED
@@ -2121,13 +2121,7 @@ function insertOp(ops, ctx, key, value, comparator) {
2121
2121
  }
2122
2122
  function deleteEntry(ops, ctx, node, key, comparator) {
2123
2123
  if (!node.leaf) {
2124
- let keyIndex = -1;
2125
- for (let i = 0, len = node.keys.length; i < len; i++) {
2126
- if (node.keys[i] === key) {
2127
- keyIndex = i;
2128
- break;
2129
- }
2130
- }
2124
+ let keyIndex = node.keys.indexOf(key);
2131
2125
  if (keyIndex !== -1) {
2132
2126
  node = cloneNode(node);
2133
2127
  node.keys.splice(keyIndex, 1);
@@ -2166,17 +2160,15 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2166
2160
  let nextNode = null;
2167
2161
  let prevValue = null;
2168
2162
  let postValue = null;
2169
- for (let i = 0, len = parentNode.keys.length; i < len; i++) {
2170
- const nKey = parentNode.keys[i];
2171
- if (nKey === node.id) {
2172
- if (i > 0) {
2173
- prevNode = ops.getNode(parentNode.keys[i - 1]);
2174
- prevValue = parentNode.values[i - 1];
2175
- }
2176
- if (i < parentNode.keys.length - 1) {
2177
- nextNode = ops.getNode(parentNode.keys[i + 1]);
2178
- postValue = parentNode.values[i];
2179
- }
2163
+ let keyIndex = parentNode.keys.indexOf(node.id);
2164
+ if (keyIndex !== -1) {
2165
+ if (keyIndex > 0) {
2166
+ prevNode = ops.getNode(parentNode.keys[keyIndex - 1]);
2167
+ prevValue = parentNode.values[keyIndex - 1];
2168
+ }
2169
+ if (keyIndex < parentNode.keys.length - 1) {
2170
+ nextNode = ops.getNode(parentNode.keys[keyIndex + 1]);
2171
+ postValue = parentNode.values[keyIndex];
2180
2172
  }
2181
2173
  }
2182
2174
  let siblingNode;
@@ -2209,7 +2201,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2209
2201
  siblingNode = node;
2210
2202
  node = pTemp;
2211
2203
  }
2212
- siblingNode.keys.push(...node.keys);
2204
+ siblingNode.keys = siblingNode.keys.concat(node.keys);
2213
2205
  if (!node.leaf) {
2214
2206
  siblingNode.values.push(guess);
2215
2207
  } else {
@@ -2220,7 +2212,7 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2220
2212
  ops.updateNode(n);
2221
2213
  }
2222
2214
  }
2223
- siblingNode.values.push(...node.values);
2215
+ siblingNode.values = siblingNode.values.concat(node.values);
2224
2216
  if (!siblingNode.leaf) {
2225
2217
  const keys = siblingNode.keys;
2226
2218
  for (let i = 0, len = keys.length; i < len; i++) {
@@ -2268,8 +2260,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2268
2260
  if (!node.leaf) {
2269
2261
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
2270
2262
  pointerK0 = siblingNode.values.splice(0, 1)[0];
2271
- node.keys = [...node.keys, pointerP0];
2272
- node.values = [...node.values, guess];
2263
+ node.keys = node.keys.concat(pointerP0);
2264
+ node.values = node.values.concat(guess);
2273
2265
  parentNode = cloneNode(ops.getNode(node.parent));
2274
2266
  const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
2275
2267
  if (pointerIndex > 0) {
@@ -2279,8 +2271,8 @@ function deleteEntry(ops, ctx, node, key, comparator) {
2279
2271
  } else {
2280
2272
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
2281
2273
  pointerK0 = siblingNode.values.splice(0, 1)[0];
2282
- node.keys = [...node.keys, pointerP0];
2283
- node.values = [...node.values, pointerK0];
2274
+ node.keys = node.keys.concat(pointerP0);
2275
+ node.values = node.values.concat(pointerK0);
2284
2276
  parentNode = cloneNode(ops.getNode(node.parent));
2285
2277
  const pointerIndex = parentNode.keys.indexOf(siblingNode.id);
2286
2278
  if (pointerIndex > 0) {
@@ -4163,13 +4155,7 @@ async function insertOpAsync(ops, ctx, key, value, comparator) {
4163
4155
  }
4164
4156
  async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4165
4157
  if (!node.leaf) {
4166
- let keyIndex = -1;
4167
- for (let i = 0, len = node.keys.length; i < len; i++) {
4168
- if (node.keys[i] === key) {
4169
- keyIndex = i;
4170
- break;
4171
- }
4172
- }
4158
+ let keyIndex = node.keys.indexOf(key);
4173
4159
  if (keyIndex !== -1) {
4174
4160
  node = cloneNode(node);
4175
4161
  node.keys.splice(keyIndex, 1);
@@ -4198,16 +4184,15 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4198
4184
  let nextNode = null;
4199
4185
  let prevValue = null;
4200
4186
  let postValue = null;
4201
- for (let i = 0, len = parentNode.keys.length; i < len; i++) {
4202
- if (parentNode.keys[i] === node.id) {
4203
- if (i > 0) {
4204
- prevNode = await ops.getNode(parentNode.keys[i - 1]);
4205
- prevValue = parentNode.values[i - 1];
4206
- }
4207
- if (i < parentNode.keys.length - 1) {
4208
- nextNode = await ops.getNode(parentNode.keys[i + 1]);
4209
- postValue = parentNode.values[i];
4210
- }
4187
+ let keyIndex = parentNode.keys.indexOf(node.id);
4188
+ if (keyIndex !== -1) {
4189
+ if (keyIndex > 0) {
4190
+ prevNode = await ops.getNode(parentNode.keys[keyIndex - 1]);
4191
+ prevValue = parentNode.values[keyIndex - 1];
4192
+ }
4193
+ if (keyIndex < parentNode.keys.length - 1) {
4194
+ nextNode = await ops.getNode(parentNode.keys[keyIndex + 1]);
4195
+ postValue = parentNode.values[keyIndex];
4211
4196
  }
4212
4197
  }
4213
4198
  let siblingNode;
@@ -4234,11 +4219,11 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4234
4219
  siblingNode = cloneNode(siblingNode);
4235
4220
  if (node.values.length + siblingNode.values.length < ctx.order) {
4236
4221
  if (!isPredecessor) {
4237
- const t = siblingNode;
4222
+ const pTemp = siblingNode;
4238
4223
  siblingNode = node;
4239
- node = t;
4224
+ node = pTemp;
4240
4225
  }
4241
- siblingNode.keys.push(...node.keys);
4226
+ siblingNode.keys = siblingNode.keys.concat(node.keys);
4242
4227
  if (!node.leaf) {
4243
4228
  siblingNode.values.push(guess);
4244
4229
  } else {
@@ -4249,7 +4234,7 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4249
4234
  await ops.updateNode(n);
4250
4235
  }
4251
4236
  }
4252
- siblingNode.values.push(...node.values);
4237
+ siblingNode.values = siblingNode.values.concat(node.values);
4253
4238
  if (!siblingNode.leaf) {
4254
4239
  for (let i = 0, len = siblingNode.keys.length; i < len; i++) {
4255
4240
  const n = cloneNode(await ops.getNode(siblingNode.keys[i]));
@@ -4293,8 +4278,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4293
4278
  if (!node.leaf) {
4294
4279
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
4295
4280
  pointerK0 = siblingNode.values.splice(0, 1)[0];
4296
- node.keys = [...node.keys, pointerP0];
4297
- node.values = [...node.values, guess];
4281
+ node.keys = node.keys.concat(pointerP0);
4282
+ node.values = node.values.concat(guess);
4298
4283
  parentNode = cloneNode(await ops.getNode(node.parent));
4299
4284
  const pi = parentNode.keys.indexOf(siblingNode.id);
4300
4285
  if (pi > 0) {
@@ -4304,8 +4289,8 @@ async function deleteEntryAsync(ops, ctx, node, key, comparator) {
4304
4289
  } else {
4305
4290
  pointerP0 = siblingNode.keys.splice(0, 1)[0];
4306
4291
  pointerK0 = siblingNode.values.splice(0, 1)[0];
4307
- node.keys = [...node.keys, pointerP0];
4308
- node.values = [...node.values, pointerK0];
4292
+ node.keys = node.keys.concat(pointerP0);
4293
+ node.values = node.values.concat(pointerK0);
4309
4294
  parentNode = cloneNode(await ops.getNode(node.parent));
4310
4295
  const pi = parentNode.keys.indexOf(siblingNode.id);
4311
4296
  if (pi > 0) {
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "serializable-bptree",
3
- "version": "9.0.3",
3
+ "version": "9.0.4-alpha.0",
4
4
  "description": "Store the B+tree flexibly, not only in-memory.",
5
5
  "types": "./dist/types/index.d.ts",
6
6
  "main": "./dist/cjs/index.cjs",