resobjectify 2.1.1 → 2.1.2

package/dist/src/fieldsBuilder.js

@@ -27,7 +27,7 @@ function fieldsBuilder() {
         return api;
     };
     const build = () => {
-        return fields;
+        return [...fields];
     };
     const api = { field, group, build };
     return api;
@@ -36,7 +36,7 @@ function fieldsBuilder() {
  * Normalizes key field shorthand into object form when needed.
  */
 function newField(key, as, options) {
-    if (!as && !options) {
+    if (as === undefined && options === undefined) {
         return key;
     }
     let entry = typeof key === "object" ? key : { key };

package/dist/src/objectify.js

@@ -2,11 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.objectify = objectify;
 function objectify(data, fields, object = false) {
-    // If the fields is a single field or object is false, group the result in an array, otherwise group the result in an object
-    const result = fields.length === 1 || !object ? [] : {};
+    if (!Array.isArray(fields) || fields.length === 0) {
+        return (object ? {} : []);
+    }
     const [keyField, ...restFields] = fields;
     const key = getKeyField(keyField);
     const name = getFieldName(keyField);
+    // Keep single root-key selections as arrays, but allow keyless group-only selections to be objects in object mode.
+    const shouldUseObjectResult = object && (fields.length > 1 || name === undefined);
+    const result = shouldUseObjectResult ? {} : [];
     // Pre-group by the current key so each recursion only sees its parent slice,
     // which removes the need for parent checks or duplicate tracking.
     const groups = groupByKey(data, key);
@@ -29,22 +33,33 @@ function objectify(data, fields, object = false) {
                 obj[fieldName] = getFieldValue(row, field);
             }
         }
-        if (name === undefined || obj[name] != null) {
-            // If the result is an array, we need to push the object to the array
-            if (Array.isArray(result)) {
-                result.push(restFields.length || name === undefined ? obj : obj[name]);
-            }
-            else {
-                // If the result is an object, we need to set the object to the key
-                result[keyValue] = obj;
-            }
-        }
+        appendToResult(result, obj, name, keyValue, restFields.length > 0);
     }
-    if (object) {
+    if (!Array.isArray(result)) {
         return result;
     }
     return result;
 }
+function appendToResult(result, obj, keyName, keyValue, hasNestedFields) {
+    // Skip groups whose root key is missing/null; for keyless grouping we always keep the object.
+    const hasKeyValue = keyName === undefined || obj[keyName] != null;
+    if (!hasKeyValue) {
+        return;
+    }
+    if (Array.isArray(result)) {
+        // In array mode, single-key selections emit the key value; otherwise emit full objects.
+        const shouldPushWholeObject = keyName === undefined || hasNestedFields;
+        result.push(shouldPushWholeObject ? obj : obj[keyName]);
+        return;
+    }
+    // In object mode without a root key, emit the aggregated object itself.
+    if (keyName === undefined) {
+        Object.assign(result, obj);
+        return;
+    }
+    // In object mode with a root key, group output by the computed key value.
+    result[keyValue] = obj;
+}
 /**
  * Groups rows by the provided key while preserving insertion order.
  */

package/dist/types.d.ts

@@ -5,7 +5,7 @@ export type Row = Record<PropertyKey, unknown>;
 /**
  * String-only key names for a given row type.
  */
-export type KeyName<T = Row> = Extract<keyof T, string> | undefined;
+export type KeyName<T = Row> = Extract<keyof T, string>;
 /**
  * Fallback string type used when strict key extraction resolves to `never`.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resobjectify",
-  "version": "2.1.1",
+  "version": "2.1.2",
   "description": "Parse an array of one dimensional objects to nested array/object",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",