seroval 0.4.0-alpha.6 → 0.4.0-alpha.7

package/dist/esm/development/index.mjs

@@ -471,21 +471,31 @@ function serializePrimitive(value) {
 }
 
 // src/tree/async.ts
-async function generateDictionary(ctx, properties) {
+async function serializePropertiesAsync(ctx, properties) {
   const keys = Object.keys(properties);
-  const nodes = {};
-  const deferred = {};
+  const size = keys.length;
+  const keyNodes = new Array(size);
+  const valueNodes = new Array(size);
+  const deferredKeys = new Array(size);
+  const deferredValues = new Array(size);
+  let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferred[key] = properties[key];
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key];
+      deferredSize++;
     } else {
-      nodes[key] = await generateTreeAsync(ctx, properties[key]);
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = await generateTreeAsync(ctx, properties[key]);
+      nodesSize++;
     }
   }
-  for (const key of Object.keys(deferred)) {
-    nodes[key] = await generateTreeAsync(ctx, deferred[key]);
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = await generateTreeAsync(ctx, deferredValues[i]);
   }
-  return nodes;
+  return [keyNodes, valueNodes, size];
 }
 async function generateSetNode(ctx, current, id) {
   assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
@@ -557,7 +567,7 @@ async function generateArrayNode(ctx, current, id) {
 }
 async function generateAggregateErrorNode(ctx, current, id) {
   const options = getErrorOptions(current);
-  const optionsNode = options ? await generateDictionary(ctx, options) : void 0;
+  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
   const errorsNode = await generateTreeAsync(ctx, current.errors);
   return [
     12 /* AggregateError */,
@@ -567,7 +577,7 @@ async function generateAggregateErrorNode(ctx, current, id) {
 }
 async function generateErrorNode(ctx, current, id) {
   const options = getErrorOptions(current);
-  const optionsNode = options ? await generateDictionary(ctx, options) : void 0;
+  const optionsNode = options ? await serializePropertiesAsync(ctx, options) : void 0;
   return [
     11 /* Error */,
     [getErrorConstructor(current), current.message, optionsNode],
@@ -579,7 +589,7 @@ async function generateIterableNode(ctx, current, id) {
   const options = getIterableOptions(current);
   return [13 /* Iterable */, [
     // Parse options first before the items
-    options ? await generateDictionary(ctx, options) : void 0,
+    options ? await serializePropertiesAsync(ctx, options) : void 0,
     await generateNodeList(ctx, Array.from(current))
   ], id];
 }
@@ -625,7 +635,7 @@ async function generateTreeAsync(ctx, current) {
   if (current.constructor === Object || empty) {
     return [
       empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      await generateDictionary(ctx, current),
+      await serializePropertiesAsync(ctx, current),
       id
     ];
   }
@@ -736,55 +746,54 @@ function createArrayAssign(ctx, ref, index, value) {
   markRef(ctx, ref);
   createAssignment(ctx, `${getRefParam(ctx, ref)}[${index}]`, value);
 }
-function createObjectAssign(ctx, ref, key, value, computed) {
+function createObjectAssign(ctx, ref, key, value) {
   markRef(ctx, ref);
-  const member = computed ? `[${key}]` : `.${key}`;
-  createAssignment(ctx, `${getRefParam(ctx, ref)}${member}`, value);
+  createAssignment(ctx, `${getRefParam(ctx, ref)}.${key}`, value);
 }
 var IDENTIFIER_CHECK = /^([$A-Z_][0-9A-Z_$]*)$/i;
-function serializeAssignments(ctx, targetRef, record) {
+function serializeAssignments(ctx, targetRef, [keys, values, size]) {
   ctx.stack.push(targetRef);
   const mainAssignments = [];
-  for (const key of Object.keys(record)) {
+  for (let i = 0; i < size; i++) {
     const parentStack = ctx.stack;
     ctx.stack = [];
-    const refParam = serializeTree(ctx, record[key]);
+    const refParam = serializeTree(ctx, values[i]);
     ctx.stack = parentStack;
+    const key = keys[i];
     const check = Number(key);
     const parentAssignment = ctx.assignments;
     ctx.assignments = mainAssignments;
     const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-    createObjectAssign(
-      ctx,
-      targetRef,
-      isIdentifier ? key : quote(key),
-      refParam,
-      !(isIdentifier && Number.isNaN(check))
-    );
+    if (isIdentifier && Number.isNaN(check)) {
+      createObjectAssign(ctx, targetRef, key, refParam);
+    } else {
+      createArrayAssign(ctx, targetRef, isIdentifier ? key : quote(key), refParam);
+    }
     ctx.assignments = parentAssignment;
   }
   ctx.stack.pop();
   return resolveAssignments(mainAssignments);
 }
-function serializeDictionary(ctx, sourceID, record) {
+function serializeObject(ctx, sourceID, [keys, values, size]) {
+  if (size === 0) {
+    return "{}";
+  }
   let result = "";
   ctx.stack.push(sourceID);
-  for (const key of Object.keys(record)) {
-    const val = record[key];
+  for (let i = 0; i < size; i++) {
+    const key = keys[i];
+    const val = values[i];
     const check = Number(key);
     const isIdentifier = check >= 0 || IDENTIFIER_CHECK.test(key);
-    const validKey = isIdentifier ? key : quote(key);
     if (isReferenceInStack(ctx, val)) {
       const refParam = getRefParam(ctx, val[1]);
-      createObjectAssign(
-        ctx,
-        sourceID,
-        validKey,
-        refParam,
-        !(isIdentifier && Number.isNaN(check))
-      );
+      if (isIdentifier && Number.isNaN(check)) {
+        createObjectAssign(ctx, sourceID, key, refParam);
+      } else {
+        createArrayAssign(ctx, sourceID, isIdentifier ? key : quote(key), refParam);
+      }
     } else {
-      result += `${validKey}:${serializeTree(ctx, val)},`;
+      result += `${isIdentifier ? key : quote(key)}:${serializeTree(ctx, val)},`;
     }
   }
   ctx.stack.pop();
@@ -894,7 +903,7 @@ function serializeArray(ctx, value, id) {
   return assignRef(ctx, id, result);
 }
 function serializeWithObjectAssign(ctx, value, id, serialized) {
-  const fields = serializeDictionary(ctx, id, value);
+  const fields = serializeObject(ctx, id, value);
   if (fields !== "{}") {
     return `Object.assign(${serialized},${fields})`;
   }
@@ -1012,28 +1021,38 @@ function serializeTree(ctx, [type, value, id]) {
     case 9 /* NullConstructor */:
       return serializeNullConstructor(ctx, value, id);
     case 8 /* Object */:
-      return assignRef(ctx, id, serializeDictionary(ctx, id, value));
+      return assignRef(ctx, id, serializeObject(ctx, id, value));
     default:
       throw new Error("Unsupported type");
   }
 }
 
 // src/tree/sync.ts
-function generateDictionary2(ctx, properties) {
+function serializePropertiesSync(ctx, properties) {
   const keys = Object.keys(properties);
-  const nodes = {};
-  const deferred = {};
+  const size = keys.length;
+  const keyNodes = new Array(size);
+  const valueNodes = new Array(size);
+  const deferredKeys = new Array(size);
+  const deferredValues = new Array(size);
+  let deferredSize = 0;
+  let nodesSize = 0;
   for (const key of keys) {
     if (isIterable(properties[key])) {
-      deferred[key] = properties[key];
+      deferredKeys[deferredSize] = key;
+      deferredValues[deferredSize] = properties[key];
+      deferredSize++;
     } else {
-      nodes[key] = generateTreeSync(ctx, properties[key]);
+      keyNodes[nodesSize] = key;
+      valueNodes[nodesSize] = generateTreeSync(ctx, properties[key]);
+      nodesSize++;
     }
   }
-  for (const key of Object.keys(deferred)) {
-    nodes[key] = generateTreeSync(ctx, deferred[key]);
+  for (let i = 0; i < deferredSize; i++) {
+    keyNodes[nodesSize + i] = deferredKeys[i];
+    valueNodes[nodesSize + i] = generateTreeSync(ctx, deferredValues[i]);
   }
-  return nodes;
+  return [keyNodes, valueNodes, size];
 }
 function generateSetNode2(ctx, current, id) {
   assert(ctx.features & 256 /* Set */, 'Unsupported type "Set"');
@@ -1105,13 +1124,13 @@ function generateArrayNode2(ctx, current, id) {
 }
 function generateAggregateErrorNode2(ctx, current, id) {
   const options = getErrorOptions(current);
-  const optionsNode = options ? generateDictionary2(ctx, options) : void 0;
+  const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
   const errorsNode = generateTreeSync(ctx, current.errors);
   return [12 /* AggregateError */, [current.message, optionsNode, errorsNode], id];
 }
 function generateErrorNode2(ctx, current, id) {
   const options = getErrorOptions(current);
-  const optionsNode = options ? generateDictionary2(ctx, options) : void 0;
+  const optionsNode = options ? serializePropertiesSync(ctx, options) : void 0;
   return [
     11 /* Error */,
     [getErrorConstructor(current), current.message, optionsNode],
@@ -1123,7 +1142,7 @@ function generateIterableNode2(ctx, current, id) {
   const options = getIterableOptions(current);
   return [13 /* Iterable */, [
     // Parse options first before the items
-    options ? generateDictionary2(ctx, options) : void 0,
+    options ? serializePropertiesSync(ctx, options) : void 0,
     generateNodeList2(ctx, Array.from(current))
   ], id];
 }
@@ -1161,7 +1180,7 @@ function generateTreeSync(ctx, current) {
   if (current.constructor === Object || empty) {
     return [
       empty ? 9 /* NullConstructor */ : 8 /* Object */,
-      generateDictionary2(ctx, current),
+      serializePropertiesSync(ctx, current),
       id
     ];
   }