seroval - npm Package Compare versions

Comparing version 0.4.0-alpha.2 to 0.4.0-alpha.3

package.json

 {
   "name": "seroval",
   "type": "module",
-  "version": "0.4.0-alpha.2",
+  "version": "0.4.0-alpha.3",
   "files": [
@@ -67,3 +67,3 @@ "dist",
   },
-  "gitHead": "cb379745d112d53472da3765b20fe5d28323cb47"
+  "gitHead": "22da3fb0f57fdb4a935cac70d1b9a7e5fdc02816"
 }

src/tree.ts

@@ -543,23 +543,26 @@ /* eslint-disable @typescript-eslint/no-use-before-define */
 ): SerovalDictionaryNode {
-  const keyNodes: string[] = [];
-  const valueNodes: SerovalNode[] = [];
-  const deferredKeys: string[] = [];
-  const deferredValues: ServerValue[] = [];
   const keys = Object.keys(properties);
+  const size = keys.length;
+  const keyNodes = new Array<string>(size);
+  const valueNodes = new Array<SerovalNode>(size);
+  const deferredKeys = new Array<string>(size);
+  const deferredValues = new Array<ServerValue>(size);
   let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferredKeys.push(key);
-      deferredValues.push(properties[key] as ServerValue);
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key] as ServerValue;
       deferredSize++;
     } else {
-      keyNodes.push(key);
-      valueNodes.push(generateTreeSync(ctx, properties[key] as ServerValue));
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key] as ServerValue);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes.push(deferredKeys[i]);
-    valueNodes.push(generateTreeSync(ctx, deferredValues[i]));
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, keys.length];
+  return [keyNodes, valueNodes, size];
 }
@@ -586,15 +589,18 @@
     assert(ctx.features.has(Feature.Set), 'Unsupported type "Set"');
-    const nodes: SerovalNode[] = [];
-    const deferred: ServerValue[] = [];
+    const len = current.size;
+    const nodes = new Array<SerovalNode>(len);
+    const deferred = new Array<ServerValue>(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
     for (const item of current.keys()) {
       // Iterables are lazy, so the evaluation must be deferred
       if (isIterable(item)) {
-        deferred.push(item);
+        deferred[deferredSize++] = item;
       } else {
-        nodes.push(generateTreeSync(ctx, item));
+        nodes[nodeSize++] = generateTreeSync(ctx, item);
       }
     }
     // Parse deferred items
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(generateTreeSync(ctx, deferred[i]));
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = generateTreeSync(ctx, deferred[i]);
     }
@@ -605,23 +611,26 @@ return [SerovalNodeType.Set, nodes, id];
     assert(ctx.features.has(Feature.Map), 'Unsupported type "Map"');
-    const keyNodes: SerovalNode[] = [];
-    const valueNodes: SerovalNode[] = [];
-    const deferredKey: ServerValue[] = [];
-    const deferredValue: ServerValue[] = [];
+    const len = current.size;
+    const keyNodes = new Array<SerovalNode>(len);
+    const valueNodes = new Array<SerovalNode>(len);
+    const deferredKey = new Array<ServerValue>(len);
+    const deferredValue = new Array<ServerValue>(len);
     let deferredSize = 0;
+    let nodeSize = 0;
     for (const [key, value] of current.entries()) {
       // Either key or value might be an iterable
       if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes.push(generateTreeSync(ctx, key));
-        valueNodes.push(generateTreeSync(ctx, value));
+        keyNodes[nodeSize] = generateTreeSync(ctx, key);
+        valueNodes[nodeSize] = generateTreeSync(ctx, value);
+        nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(generateTreeSync(ctx, deferredKey[i]));
-      valueNodes.push(generateTreeSync(ctx, deferredValue[i]));
+      keyNodes[nodeSize + i] = generateTreeSync(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = generateTreeSync(ctx, deferredValue[i]);
     }
-    return [SerovalNodeType.Map, [keyNodes, valueNodes, current.size], id];
+    return [SerovalNodeType.Map, [keyNodes, valueNodes, len], id];
   }
@@ -691,23 +700,26 @@ if (Array.isArray(current)) {
 ): Promise<SerovalDictionaryNode> {
-  const keyNodes: string[] = [];
-  const valueNodes: SerovalNode[] = [];
-  const deferredKeys: string[] = [];
-  const deferredValues: ServerValue[] = [];
   const keys = Object.keys(properties);
+  const size = keys.length;
+  const keyNodes = new Array<string>(size);
+  const valueNodes = new Array<SerovalNode>(size);
+  const deferredKeys = new Array<string>(size);
+  const deferredValues = new Array<ServerValue>(size);
   let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferredKeys.push(key);
-      deferredValues.push(properties[key] as ServerValue);
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key] as ServerValue;
       deferredSize++;
     } else {
-      keyNodes.push(key);
-      valueNodes.push(await generateTreeAsync(ctx, properties[key] as ServerValue));
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key] as ServerValue);
+      nodesSize++;
     }
   }
   for (let i = 0; i < deferredSize; i++) {
-    keyNodes.push(deferredKeys[i]);
-    valueNodes.push(await generateTreeAsync(ctx, deferredValues[i]));
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
   }
-  return [keyNodes, valueNodes, keys.length];
+  return [keyNodes, valueNodes, size];
 }
@@ -740,13 +752,18 @@
     assert(ctx.features.has(Feature.Set), 'Unsupported type "Set"');
-    const nodes: SerovalNode[] = [];
-    const deferred: AsyncServerValue[] = [];
+    const len = current.size;
+    const nodes = new Array<SerovalNode>(len);
+    const deferred = new Array<AsyncServerValue>(len);
+    let deferredSize = 0;
+    let nodeSize = 0;
     for (const item of current.keys()) {
+      // Iterables are lazy, so the evaluation must be deferred
       if (isIterable(item)) {
-        deferred.push(item);
+        deferred[deferredSize++] = item;
       } else {
-        nodes.push(await generateTreeAsync(ctx, item));
+        nodes[nodeSize++] = await generateTreeAsync(ctx, item);
       }
     }
-    for (let i = 0, len = deferred.length; i < len; i++) {
-      nodes.push(await generateTreeAsync(ctx, deferred[i]));
+    // Parse deferred items
+    for (let i = 0; i < deferredSize; i++) {
+      nodes[nodeSize + i] = await generateTreeAsync(ctx, deferred[i]);
     }
@@ -757,22 +774,26 @@ return [SerovalNodeType.Set, nodes, id];
     assert(ctx.features.has(Feature.Map), 'Unsupported type "Map"');
-    const keyNodes: SerovalNode[] = [];
-    const valueNodes: SerovalNode[] = [];
-    const deferredKey: AsyncServerValue[] = [];
-    const deferredValue: AsyncServerValue[] = [];
+    const len = current.size;
+    const keyNodes = new Array<SerovalNode>(len);
+    const valueNodes = new Array<SerovalNode>(len);
+    const deferredKey = new Array<AsyncServerValue>(len);
+    const deferredValue = new Array<AsyncServerValue>(len);
     let deferredSize = 0;
+    let nodeSize = 0;
     for (const [key, value] of current.entries()) {
+      // Either key or value might be an iterable
       if (isIterable(key) || isIterable(value)) {
-        deferredKey.push(key);
-        deferredValue.push(value);
+        deferredKey[deferredSize] = key;
+        deferredValue[deferredSize] = value;
         deferredSize++;
       } else {
-        keyNodes.push(await generateTreeAsync(ctx, key));
-        valueNodes.push(await generateTreeAsync(ctx, value));
+        keyNodes[nodeSize] = await generateTreeAsync(ctx, key);
+        valueNodes[nodeSize] = await generateTreeAsync(ctx, value);
+        nodeSize++;
       }
     }
     for (let i = 0; i < deferredSize; i++) {
-      keyNodes.push(await generateTreeAsync(ctx, deferredKey[i]));
-      valueNodes.push(await generateTreeAsync(ctx, deferredValue[i]));
+      keyNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredKey[i]);
+      valueNodes[nodeSize + i] = await generateTreeAsync(ctx, deferredValue[i]);
     }
-    return [SerovalNodeType.Map, [keyNodes, valueNodes, current.size], id];
+    return [SerovalNodeType.Map, [keyNodes, valueNodes, len], id];
   }
@@ -893,10 +914,7 @@ if (Array.isArray(current)) {
     const check = Number(key);
+    const parentAssignment = ctx.assignments;
+    ctx.assignments = mainAssignments;
     // Test if key is a valid number or JS identifier
     // so that we don't have to serialize the key and wrap with brackets
-    const parentAssignment = ctx.assignments;
-    ctx.assignments = mainAssignments;
-    if (
-      check >= 0
-      || (Number.isNaN(check) && IDENTIFIER_CHECK.test(key))
-    ) {
+    if (IDENTIFIER_CHECK.test(key) || check >= 0) {
       if (!Number.isNaN(check)) {
@@ -929,8 +947,6 @@ createObjectComputedAssign(ctx, targetRef, key, refParam);
     // so that we don't have to serialize the key and wrap with brackets
-    if (
-      check >= 0
-      || (Number.isNaN(check) && IDENTIFIER_CHECK.test(key))
-    ) {
-      if (isReferenceInStack(ctx, val)) {
-        const refParam = getRefParam(ctx, val[1]);
+    const isIdentifier = IDENTIFIER_CHECK.test(key) || check >= 0;
+    if (isReferenceInStack(ctx, val)) {
+      const refParam = getRefParam(ctx, val[1]);
+      if (isIdentifier) {
         if (!Number.isNaN(check)) {
@@ -942,7 +958,6 @@ createObjectComputedAssign(ctx, sourceID, key, refParam);
       } else {
-        result += `${key}:${serializeTree(ctx, val)},`;
+        createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
       }
-    } else if (isReferenceInStack(ctx, val)) {
-      const refParam = getRefParam(ctx, val[1]);
-      createObjectComputedAssign(ctx, sourceID, quote(key), refParam);
+    } else if (isIdentifier) {
+      result += `${key}:${serializeTree(ctx, val)},`;
     } else {
@@ -949,0 +964,0 @@ result += `${quote(key)}:${serializeTree(ctx, val)},`;

No alert changes

Improved metrics

Total package byte prevSize

346726

increased by1.62%

Lines of code

4371

increased by1.23%

No dependency changes