resobjectify 2.1.0 → 2.1.1

package/dist/index.d.ts

@@ -1,23 +1,3 @@
-import type { FieldsBuilder, Fields, Prettify, Row } from "./types";
-export type { Fields, FieldsBuilder } from "./types";
-export declare function fieldsBuilder<R = Row, T = Row>(): FieldsBuilder<R, T>;
-export declare function objectify<R = unknown, T = Row>(
-	data: T[],
-	fields: Fields<R, T>,
-	object: true,
-): Record<PropertyKey, Prettify<R>>;
-export declare function objectify<R = unknown, T = Row>(
-	data: T[],
-	fields: Fields<R, T>,
-	object?: false,
-): Prettify<R>[];
-export declare function objectify<R = unknown>(
-	data: Row[],
-	fields: Fields<R>,
-	object: true,
-): Record<PropertyKey, Prettify<R>>;
-export declare function objectify<R = unknown>(
-	data: Row[],
-	fields: Fields<R>,
-	object?: false,
-): Prettify<R>[];
+export * from "./src/fieldsBuilder";
+export * from "./src/objectify";
+export type { Field } from "./types";

package/dist/index.js

@@ -1,153 +1,18 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldsBuilder = fieldsBuilder;
-exports.objectify = objectify;
-function fieldsBuilder() {
-    const fields = [];
-    function newField(key, as, options) {
-        if (!as && !options) {
-            return key;
-        }
-        let entry = typeof key === "object" ? key : { key };
-        if (as !== undefined) {
-            entry = { ...entry, as: as };
-        }
-        if (options !== undefined) {
-            entry = { ...entry, ...options };
-        }
-        return entry;
-    }
-    function newGroup(groupField, options) {
-        if (!options) {
-            return groupField;
-        }
-        let entry = typeof groupField === "object" ? groupField : { name: groupField };
-        if (options) {
-            entry = { ...entry, ...options };
-        }
-        return entry;
-    }
-    const field = (field, asOrOptions, options) => {
-        const isOptions = typeof asOrOptions === "object"
-            && asOrOptions !== null
-            && "json" in asOrOptions;
-        const resolvedAs = isOptions ? undefined : asOrOptions;
-        const resolvedOptions = isOptions ? asOrOptions : options;
-        //Create the new field entry
-        const entry = newField(field, resolvedAs, resolvedOptions);
-        fields.push(entry);
-        return api;
-    };
-    const group = (name, optionsOrBuild, build) => {
-        const options = typeof optionsOrBuild === "object" ? optionsOrBuild : undefined;
-        const buildFn = typeof optionsOrBuild === "function" ? optionsOrBuild : build;
-        if (!buildFn) {
-            throw new Error("Group builder requires a builder callback.");
-        }
-        const nested = buildFn(fieldsBuilder()).build();
-        const groupField = newGroup(name, options);
-        fields.push([groupField, nested]);
-        return api;
-    };
-    const build = () => {
-        if (fields.length === 0 || Array.isArray(fields[0])) {
-            throw new Error("Fields builder requires the first field to be a key field.");
-        }
-        return fields;
-    };
-    const api = { field, group, build };
-    return api;
-}
-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 ? [] : {};
-    const [keyField, ...restFields] = fields;
-    const key = getKeyField(keyField);
-    const name = getFieldName(keyField);
-    // 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);
-    for (const [keyValue, rows] of groups) {
-        const row = rows[0];
-        const obj = {};
-        for (const field of fields) {
-            // If the field is not an array, it is a key field, so we can get the value from the row
-            if (!Array.isArray(field)) {
-                const fieldName = getFieldName(field);
-                obj[fieldName] = getFieldValue(row, field);
-            }
-            else { // If the field is an array, it is a group field, so we need to objectify the nested fields recursively
-                const [rawGroupField, nestedFields] = field;
-                const groupField = rawGroupField;
-                const nestedObject = isObject(groupField, object);
-                obj[getGroupName(groupField)] = nestedObject
-                    ? objectify(rows, nestedFields, true)
-                    : objectify(rows, nestedFields, false);
-            }
-        }
-        if (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 ? obj : obj[name]);
-            }
-            else { // If the result is an object, we need to set the object to the key
-                result[keyValue] = obj;
-            }
-        }
-    }
-    if (object) {
-        return result;
-    }
-    return result;
-}
-// Groups rows by the current key, preserving first-seen order.
-function groupByKey(rows, key) {
-    const groups = new Map();
-    for (const row of rows) {
-        const keyValue = row[key];
-        const group = groups.get(keyValue);
-        if (group) {
-            group.push(row);
-        }
-        else {
-            groups.set(keyValue, [row]);
-        }
-    }
-    return groups;
-}
-function getKeyField(field) {
-    return (typeof field === "string" ? field : field.key);
-}
-function getFieldName(field) {
-    var _a;
-    return (typeof field === "string" ? field : ((_a = field.as) !== null && _a !== void 0 ? _a : field.key));
-}
-function getFieldValue(row, field) {
-    if (typeof field === "string") {
-        return row[field];
-    }
-    const key = getKeyField(field);
-    if (field.json) {
-        try {
-            return JSON.parse(row[key]);
-        }
-        catch (error) {
-            console.error(`"${row[key]}" is not a valid JSON`, error);
-            return null;
-        }
-    }
-    return row[key];
-}
-function getGroupName(field) {
-    if (typeof field === "string" || typeof field === "number" || typeof field === "symbol") {
-        return field;
-    }
-    return field.name;
-}
-function isObject(field, defaultValue) {
-    var _a;
-    if (typeof field !== "object" || field == null) {
-        return defaultValue;
-    }
-    return (_a = field.object) !== null && _a !== void 0 ? _a : defaultValue;
-}
+__exportStar(require("./src/fieldsBuilder"), exports);
+__exportStar(require("./src/objectify"), exports);

package/dist/src/fieldsBuilder.d.ts

@@ -0,0 +1,5 @@
+import type { FieldsBuilder, Row } from "../types";
+/**
+ * Creates a fluent builder for composing `Fields` definitions.
+ */
+export declare function fieldsBuilder<R = Row, T = Row>(): FieldsBuilder<R, T>;

package/dist/src/fieldsBuilder.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldsBuilder = fieldsBuilder;
+/**
+ * Creates a fluent builder for composing `Fields` definitions.
+ */
+function fieldsBuilder() {
+    const fields = [];
+    const field = (field, asOrOptions, options) => {
+        const isOptions = typeof asOrOptions === "object" && asOrOptions !== null && "json" in asOrOptions;
+        const resolvedAs = isOptions ? undefined : asOrOptions;
+        const resolvedOptions = isOptions ? asOrOptions : options;
+        // Normalize overload inputs into a single key-field shape.
+        const entry = newField(field, resolvedAs, resolvedOptions);
+        fields.push(entry);
+        return api;
+    };
+    const group = (name, optionsOrBuild, build) => {
+        const options = typeof optionsOrBuild === "object" ? optionsOrBuild : undefined;
+        const buildFn = typeof optionsOrBuild === "function" ? optionsOrBuild : build;
+        if (!buildFn) {
+            throw new Error("Group builder requires a builder callback.");
+        }
+        const nested = buildFn(fieldsBuilder()).build();
+        const groupField = newGroup(name, options);
+        fields.push([groupField, nested]);
+        return api;
+    };
+    const build = () => {
+        return fields;
+    };
+    const api = { field, group, build };
+    return api;
+}
+/**
+ * Normalizes key field shorthand into object form when needed.
+ */
+function newField(key, as, options) {
+    if (!as && !options) {
+        return key;
+    }
+    let entry = typeof key === "object" ? key : { key };
+    if (as !== undefined) {
+        entry = { ...entry, as: as };
+    }
+    if (options !== undefined) {
+        entry = { ...entry, ...options };
+    }
+    return entry;
+}
+/**
+ * Normalizes group shorthand into object form when options are provided.
+ */
+function newGroup(groupField, options) {
+    if (!options) {
+        return groupField;
+    }
+    let entry = typeof groupField === "object" ? groupField : { name: groupField };
+    if (options) {
+        entry = { ...entry, ...options };
+    }
+    return entry;
+}

package/package.json

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