nextjs-cms 0.5.9 → 0.5.11

package/dist/core/factories/FieldFactory.js

@@ -1,411 +1,411 @@
-import { sql } from 'drizzle-orm';
-import { db } from "../../db/client.js";
-import { SectionFactory } from "./SectionFactory.js";
-import { SimpleSection, HasItemsSection, CategorySection } from "../sections.js";
-import { checkboxField, SelectField, SelectMultipleField } from "../fields.js";
-import { is } from "../helpers.js";
-import { cloneDeep } from 'lodash-es';
-import chalk from 'chalk';
-export class FieldFactory {
-    session;
-    _values = {};
-    itemId = undefined;
-    _error = false;
-    _errorMessage = '';
-    type;
-    sectionName;
-    _sectionInfo;
-    // private _fields: Field[]
-    /**
-     * Default order value for items without explicit order.
-     * Ensures items without order come after explicitly ordered items.
-     * Typical order values: 0-15, with occasional values up to 1000.
-     */
-    static DEFAULT_ORDER = 1_000_000;
-    /**
-     * Constructor
-     */
-    constructor({ type, sectionName, session, itemId }) {
-        this.type = type;
-        this.sectionName = sectionName;
-        this.session = session;
-        this.itemId = itemId;
-        // this._fields = new Array<Field>()
-        this._sectionInfo = undefined;
-    }
-    /**
-     * Must be called after the constructor
-     */
-    async initialize() {
-        await this.initializeSectionInfo(this.session);
-        /**
-         * If it's an edit operation, let's initialize the field values
-         */
-        if (this.type === 'edit') {
-            await this.initializeFieldValues();
-        }
-    }
-    async getFieldValue(field) {
-        if (this.type === 'new')
-            return undefined;
-        try {
-            return this._values[field.name];
-        }
-        catch (e) {
-            return undefined;
-        }
-    }
-    async initializeFieldValues() {
-        if (this._error)
-            return;
-        if (this._sectionInfo?.db.table && this._sectionInfo.db.identifier) {
-            /**
-             * Let's get the section item values from its table and assign it to the `_values` property
-             */
-            // TODO: We still need to get the values from the `destinationDbTable` if it exists on any field
-            //  also, select_multiple fields need to be handled the same way, plus value is array of strings
-            const [_v, fields] = await db.execute(sql `select * from ${sql.raw(this._sectionInfo.db.table)} where ${sql.raw(this._sectionInfo.db.identifier.name)} = ${this.itemId} limit 1`);
-            // @ts-ignore
-            // Bug: this is a bug in drizzle-orm/mysql2
-            this._values = _v[0];
-            /**
-             * If the field has a destinationDb
-             * Get the result from the field's table and the destinationDb's table using a JOIN query
-             * Fields that can have a destinationDb are: SelectField, SelectMultipleField, TagsField
-             */
-            for (const field of this._sectionInfo.fields) {
-                if (field.destinationDb && (is(field, SelectMultipleField) || is(field, SelectField))) {
-                    const sqlChunks = [
-                        sql `select * from ${sql.raw(field.destinationDb.table)} a JOIN ${sql.raw(field.db.table)} b ON a.${sql.raw(field.destinationDb.selectIdentifier)} = b.${sql.raw(field.db.identifier)} where ${sql.raw(field.destinationDb.itemIdentifier)} = ${this.itemId}`,
-                    ];
-                    if (is(field, SelectField) && field.hasDepth()) {
-                        /**
-                         * Add the where clause to the select statement
-                         */
-                        sqlChunks.push(sql ` ORDER BY b.level ASC`);
-                    }
-                    const [_rows, _fields] = await db.execute(sql.join(sqlChunks));
-                    const values = [];
-                    if (Array.isArray(_rows)) {
-                        for (const row of _rows) {
-                            values.push({
-                                value: row[field.destinationDb.selectIdentifier],
-                                label: row[field.db.label],
-                            });
-                        }
-                    }
-                    this._values[field.name] = values;
-                }
-            }
-            /**
-             * If the section item is not found, set the `_error` property to true
-             */
-            if (!is(this._sectionInfo, SimpleSection) && !this._values) {
-                this._error = true;
-                this._errorMessage = 'Item not found';
-                return;
-            }
-        }
-        else {
-            this._error = true;
-            this._errorMessage = 'Section table or section table identifier is missing';
-            return;
-        }
-    }
-    /**
-     * Gets the section info and assigns it to the `sectionInfo` property
-     * @param session
-     * @private
-     */
-    async initializeSectionInfo(session) {
-        /**
-         * Get section info - could be a config (with build()) or an instance
-         * Section files should export configs, but we handle both for backward compatibility
-         */
-        let _s = await this.getSectionInfo(session);
-        if (_s === undefined)
-            return;
-        /**
-         * Build the section from config when we need to use it
-         * SectionFactory returns configs, so we always build them here
-         *
-         * Double check if the config has a build() method
-         */
-        if (typeof _s.build === 'function') {
-            // It's a config - build it to get a fresh instance
-            // We build here because we immediately need to access section properties (db.table, inputs, etc.)
-            this._sectionInfo = _s.build();
-            /**
-             * Build the fields from the field configs
-             */
-            this._sectionInfo.buildFields();
-        }
-        else {
-            const errorMessage = 'Section config must have a build() method. Use helper functions like simpleSection(), hasItemsSection(), categorySection() to create section configs.';
-            console.error(chalk.bold.red('[FieldFactory Error]', errorMessage));
-            this._error = true;
-            this._errorMessage = errorMessage;
-            throw new Error(errorMessage);
-        }
-        /**
-         * Unset the `_s` variable to be garbage collected
-         */
-        _s = undefined;
-    }
-    /**
-     * Get the section info from the `sectionsTable` table
-     * @param session
-     * @private
-     */
-    async getSectionInfo(session) {
-        /**
-         * First, let's get the section details, and then get the section input fields
-         */
-        const s = await SectionFactory.getSectionForAdmin({
-            name: this.sectionName,
-            admin: {
-                id: session.user.id,
-                requiredRole: this.type === 'new' ? 'C' : 'U',
-            },
-        });
-        if (!s || !s.name) {
-            this._error = true;
-            this._errorMessage = 'Section not found or you do not have access to this operation';
-            return undefined;
-        }
-        return s;
-    }
-    /**
-     * Prepare a field for use
-     * Fields are already instances (resolved in Section constructor), so we just need to set values
-     * @param field
-     */
-    async prepareField(field) {
-        // Fields are already instances - no need to build them
-        // They were resolved from configs in the Section constructor
-        if (this.type === 'edit') {
-            /**
-             * If it's an edit operation, get the value from the database and set it
-             */
-            const value = await this.getFieldValue(field);
-            // It's important to set the value to whatever is in the database,
-            // even if the field has a `defaultValue` set.
-            field.setValue(value);
-        }
-    }
-    // TODO: Implement this, maybe set the roles in the trpc context?
-    addPermissionField() {
-        if (is(this._sectionInfo, HasItemsSection)) {
-            if (this._sectionInfo.requirePublishPermission && this.session.user) {
-                return checkboxField({
-                    name: 'publish',
-                    label: 'Publish',
-                    required: true,
-                    order: 1000,
-                });
-            }
-        }
-    }
-    /**
-     * Generate the fields
-     */
-    async generateFields() {
-        if (this._error)
-            return;
-        if (!this._sectionInfo)
-            return;
-        for (const input of this._sectionInfo.fields) {
-            /**
-             * If it's an edit operation, set the field to readonly if it's the identifier field,
-             * identifier fields must not be edited!
-             * They are always visible as a readonly text.
-             */
-            if (this.type === 'edit' && input.name === this._sectionInfo.db.identifier.name) {
-                input.adminGenerated = 'readonly';
-            }
-            /**
-             * Prepare the field (set values if editing)
-             */
-            await this.prepareField(input);
-        }
-        this.sortFields();
-    }
-    /**
-     * Sort the fields.
-     * This function sorts the conditional fields into their respective fields.
-     */
-    sortFields() {
-        if (this._error)
-            return;
-        if (!this._sectionInfo)
-            return;
-        /**
-         * Create a map of conditional fields
-         */
-        const _conditionalFieldMap = new Map();
-        /**
-         * Loop through the fields and get the conditional fields
-         */
-        for (const input of this._sectionInfo.fields) {
-            input.conditionalFields = [];
-            /**
-             * Check if the field is conditional.
-             */
-            if (input.isConditional()) {
-                for (const rule of input.conditionalRules ?? []) {
-                    /**
-                     * Add the conditional input to the conditional fields lists
-                     */
-                    if (!_conditionalFieldMap.has(rule.field.name)) {
-                        _conditionalFieldMap.set(rule.field.name, []);
-                    }
-                    _conditionalFieldMap.get(rule.field.name).push(
-                    /**
-                     * Clone the conditional field to avoid reference issues
-                     */
-                    cloneDeep({
-                        field: input.exportForClient(),
-                        rule: {
-                            condition: rule.condition,
-                            value: rule.value,
-                        },
-                    }));
-                }
-            }
-        }
-        /**
-         * Assign conditionalFields to the appropriate fields
-         */
-        for (const field of this._sectionInfo.fields) {
-            const matchingConditionalFields = _conditionalFieldMap.get(field.name);
-            if (matchingConditionalFields) {
-                field.conditionalFields.push(...matchingConditionalFields.map((clonedConditionalField) => ({
-                    ...clonedConditionalField,
-                    rule: {
-                        condition: clonedConditionalField.rule.condition,
-                        value: clonedConditionalField.rule.value,
-                    },
-                })));
-            }
-        }
-        /**
-         * Destroy the map
-         */
-        _conditionalFieldMap.clear();
-    }
-    /**
-     * Sort fields by their order property, preserving original position for fields without order.
-     *
-     * Sorting behavior:
-     * 1. Fields with explicit `order` values are sorted by that value (ascending)
-     * 2. Fields without `order` maintain their original array position (stable sort)
-     * 3. Fields with the same `order` value maintain their relative positions (stable sort)
-     *
-     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
-     * Note: This mutates the input array for performance.
-     *
-     * @param fields - Array of fields to sort (will be mutated)
-     * @returns The sorted array (same reference as input)
-     * @private
-     */
-    sortFieldsByOrder(fields) {
-        // Sort in-place for performance (mutates array)
-        // JavaScript's sort is stable (ES2019+), so equal values maintain original order
-        return fields.sort((a, b) => (a.order ?? FieldFactory.DEFAULT_ORDER) - (b.order ?? FieldFactory.DEFAULT_ORDER));
-    }
-    /**
-     * Sort groups by their groupOrder property, preserving original position for groups without order.
-     *
-     * Sorting behavior:
-     * 1. Groups with explicit `groupOrder` values are sorted by that value (ascending)
-     * 2. Groups without `groupOrder` maintain their original array position (stable sort)
-     * 3. Groups with the same `groupOrder` value maintain their relative positions (stable sort)
-     *
-     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
-     * Note: This mutates the input array for performance.
-     * Note: groupOrder is normalized at creation time, so no nullish coalescing needed here.
-     *
-     * @param groups - Array of groups to sort (will be mutated)
-     * @returns The sorted array (same reference as input)
-     * @private
-     */
-    sortGroupsByOrder(groups) {
-        // Sort in-place for performance (mutates array)
-        // JavaScript's sort is stable (ES2019+), so equal values maintain original order
-        // groupOrder is normalized at creation time, so direct subtraction is safe
-        return groups.sort((a, b) => a.groupOrder - b.groupOrder);
-    }
-    /**
-     * Get field groups with filtered and sorted fields.
-     * Leverages the pre-built fieldGroups from the Section class for better performance.
-     */
-    getGroupedFields() {
-        if (this._error)
-            return;
-        if (!this._sectionInfo)
-            return;
-        const fieldGroups = this._sectionInfo.fieldGroups;
-        const isNewOperation = this.type === 'new';
-        const isEditOperation = this.type === 'edit';
-        const isCategorySection = is(this._sectionInfo, CategorySection);
-        // Build groups in a single pass, skipping empty groups
-        const processedGroups = [];
-        for (let i = 0, len = fieldGroups.length; i < len; i++) {
-            const group = fieldGroups[i];
-            if (!group)
-                continue;
-            const fields = group.fields;
-            const validFields = [];
-            // Filter and collect valid fields in one pass
-            for (let j = 0, fieldLen = fields.length; j < fieldLen; j++) {
-                const field = fields[j];
-                if (!field)
-                    continue;
-                // Skip conditional fields (they're nested in their parent field)
-                if (field.isConditional())
-                    continue;
-                // For new item operations, exclude fields with adminGenerated not set to true
-                if (isNewOperation && field.adminGenerated !== true)
-                    continue;
-                // For edit operations, exclude fields with adminGenerated set to false
-                if (isEditOperation && field.adminGenerated === false)
-                    continue;
-                // For category sections, exclude parent_id and level fields
-                if (isCategorySection && (field.name === 'parent_id' || field.name === 'level'))
-                    continue;
-                /**
-                 * Add the field to the valid fields array
-                 */
-                validFields.push(field);
-            }
-            /**
-             * Only return the group if it has valid fields
-             */
-            if (validFields.length > 0) {
-                processedGroups.push({
-                    groupId: group.id,
-                    groupTitle: group.title ?? '',
-                    // Normalize order value here to avoid checking again in sort function
-                    groupOrder: group.order ?? FieldFactory.DEFAULT_ORDER,
-                    inputs: this.sortFieldsByOrder(validFields).map((field) => field.exportForClient()),
-                });
-            }
-        }
-        // Sort groups by order using the optimized function
-        this.sortGroupsByOrder(processedGroups);
-        /**
-         * Unset the section info to be garbage collected
-         */
-        this._sectionInfo = null;
-        return processedGroups;
-    }
-    get sectionInfo() {
-        return this._sectionInfo ?? undefined;
-    }
-    get errorMessage() {
-        return this._errorMessage;
-    }
-    get error() {
-        return this._error;
-    }
-}
+import { sql } from 'drizzle-orm';
+import { db } from '../../db/client.js';
+import { SectionFactory } from './SectionFactory.js';
+import { SimpleSection, HasItemsSection, CategorySection } from '../sections/index.js';
+import { checkboxField, SelectField, SelectMultipleField } from '../fields/index.js';
+import { is } from '../helpers/index.js';
+import { cloneDeep } from 'lodash-es';
+import chalk from 'chalk';
+export class FieldFactory {
+    session;
+    _values = {};
+    itemId = undefined;
+    _error = false;
+    _errorMessage = '';
+    type;
+    sectionName;
+    _sectionInfo;
+    // private _fields: Field[]
+    /**
+     * Default order value for items without explicit order.
+     * Ensures items without order come after explicitly ordered items.
+     * Typical order values: 0-15, with occasional values up to 1000.
+     */
+    static DEFAULT_ORDER = 1_000_000;
+    /**
+     * Constructor
+     */
+    constructor({ type, sectionName, session, itemId }) {
+        this.type = type;
+        this.sectionName = sectionName;
+        this.session = session;
+        this.itemId = itemId;
+        // this._fields = new Array<Field>()
+        this._sectionInfo = undefined;
+    }
+    /**
+     * Must be called after the constructor
+     */
+    async initialize() {
+        await this.initializeSectionInfo(this.session);
+        /**
+         * If it's an edit operation, let's initialize the field values
+         */
+        if (this.type === 'edit') {
+            await this.initializeFieldValues();
+        }
+    }
+    async getFieldValue(field) {
+        if (this.type === 'new')
+            return undefined;
+        try {
+            return this._values[field.name];
+        }
+        catch (e) {
+            return undefined;
+        }
+    }
+    async initializeFieldValues() {
+        if (this._error)
+            return;
+        if (this._sectionInfo?.db.table && this._sectionInfo.db.identifier) {
+            /**
+             * Let's get the section item values from its table and assign it to the `_values` property
+             */
+            // TODO: We still need to get the values from the `destinationDbTable` if it exists on any field
+            //  also, select_multiple fields need to be handled the same way, plus value is array of strings
+            const [_v, fields] = await db.execute(sql `select * from ${sql.raw(this._sectionInfo.db.table)} where ${sql.raw(this._sectionInfo.db.identifier.name)} = ${this.itemId} limit 1`);
+            // @ts-ignore
+            // Bug: this is a bug in drizzle-orm/mysql2
+            this._values = _v[0];
+            /**
+             * If the field has a destinationDb
+             * Get the result from the field's table and the destinationDb's table using a JOIN query
+             * Fields that can have a destinationDb are: SelectField, SelectMultipleField, TagsField
+             */
+            for (const field of this._sectionInfo.fields) {
+                if (field.destinationDb && (is(field, SelectMultipleField) || is(field, SelectField))) {
+                    const sqlChunks = [
+                        sql `select * from ${sql.raw(field.destinationDb.table)} a JOIN ${sql.raw(field.db.table)} b ON a.${sql.raw(field.destinationDb.selectIdentifier)} = b.${sql.raw(field.db.identifier)} where ${sql.raw(field.destinationDb.itemIdentifier)} = ${this.itemId}`,
+                    ];
+                    if (is(field, SelectField) && field.hasDepth()) {
+                        /**
+                         * Add the where clause to the select statement
+                         */
+                        sqlChunks.push(sql ` ORDER BY b.level ASC`);
+                    }
+                    const [_rows, _fields] = await db.execute(sql.join(sqlChunks));
+                    const values = [];
+                    if (Array.isArray(_rows)) {
+                        for (const row of _rows) {
+                            values.push({
+                                value: row[field.destinationDb.selectIdentifier],
+                                label: row[field.db.label],
+                            });
+                        }
+                    }
+                    this._values[field.name] = values;
+                }
+            }
+            /**
+             * If the section item is not found, set the `_error` property to true
+             */
+            if (!is(this._sectionInfo, SimpleSection) && !this._values) {
+                this._error = true;
+                this._errorMessage = 'Item not found';
+                return;
+            }
+        }
+        else {
+            this._error = true;
+            this._errorMessage = 'Section table or section table identifier is missing';
+            return;
+        }
+    }
+    /**
+     * Gets the section info and assigns it to the `sectionInfo` property
+     * @param session
+     * @private
+     */
+    async initializeSectionInfo(session) {
+        /**
+         * Get section info - could be a config (with build()) or an instance
+         * Section files should export configs, but we handle both for backward compatibility
+         */
+        let _s = await this.getSectionInfo(session);
+        if (_s === undefined)
+            return;
+        /**
+         * Build the section from config when we need to use it
+         * SectionFactory returns configs, so we always build them here
+         *
+         * Double check if the config has a build() method
+         */
+        if (typeof _s.build === 'function') {
+            // It's a config - build it to get a fresh instance
+            // We build here because we immediately need to access section properties (db.table, inputs, etc.)
+            this._sectionInfo = _s.build();
+            /**
+             * Build the fields from the field configs
+             */
+            this._sectionInfo.buildFields();
+        }
+        else {
+            const errorMessage = 'Section config must have a build() method. Use helper functions like simpleSection(), hasItemsSection(), categorySection() to create section configs.';
+            console.error(chalk.bold.red('[FieldFactory Error]', errorMessage));
+            this._error = true;
+            this._errorMessage = errorMessage;
+            throw new Error(errorMessage);
+        }
+        /**
+         * Unset the `_s` variable to be garbage collected
+         */
+        _s = undefined;
+    }
+    /**
+     * Get the section info from the `sectionsTable` table
+     * @param session
+     * @private
+     */
+    async getSectionInfo(session) {
+        /**
+         * First, let's get the section details, and then get the section input fields
+         */
+        const s = await SectionFactory.getSectionForAdmin({
+            name: this.sectionName,
+            admin: {
+                id: session.user.id,
+                requiredRole: this.type === 'new' ? 'C' : 'U',
+            },
+        });
+        if (!s || !s.name) {
+            this._error = true;
+            this._errorMessage = 'Section not found or you do not have access to this operation';
+            return undefined;
+        }
+        return s;
+    }
+    /**
+     * Prepare a field for use
+     * Fields are already instances (resolved in Section constructor), so we just need to set values
+     * @param field
+     */
+    async prepareField(field) {
+        // Fields are already instances - no need to build them
+        // They were resolved from configs in the Section constructor
+        if (this.type === 'edit') {
+            /**
+             * If it's an edit operation, get the value from the database and set it
+             */
+            const value = await this.getFieldValue(field);
+            // It's important to set the value to whatever is in the database,
+            // even if the field has a `defaultValue` set.
+            field.setValue(value);
+        }
+    }
+    // TODO: Implement this, maybe set the roles in the trpc context?
+    addPermissionField() {
+        if (is(this._sectionInfo, HasItemsSection)) {
+            if (this._sectionInfo.requirePublishPermission && this.session.user) {
+                return checkboxField({
+                    name: 'publish',
+                    label: 'Publish',
+                    required: true,
+                    order: 1000,
+                });
+            }
+        }
+    }
+    /**
+     * Generate the fields
+     */
+    async generateFields() {
+        if (this._error)
+            return;
+        if (!this._sectionInfo)
+            return;
+        for (const input of this._sectionInfo.fields) {
+            /**
+             * If it's an edit operation, set the field to readonly if it's the identifier field,
+             * identifier fields must not be edited!
+             * They are always visible as a readonly text.
+             */
+            if (this.type === 'edit' && input.name === this._sectionInfo.db.identifier.name) {
+                input.adminGenerated = 'readonly';
+            }
+            /**
+             * Prepare the field (set values if editing)
+             */
+            await this.prepareField(input);
+        }
+        this.sortFields();
+    }
+    /**
+     * Sort the fields.
+     * This function sorts the conditional fields into their respective fields.
+     */
+    sortFields() {
+        if (this._error)
+            return;
+        if (!this._sectionInfo)
+            return;
+        /**
+         * Create a map of conditional fields
+         */
+        const _conditionalFieldMap = new Map();
+        /**
+         * Loop through the fields and get the conditional fields
+         */
+        for (const input of this._sectionInfo.fields) {
+            input.conditionalFields = [];
+            /**
+             * Check if the field is conditional.
+             */
+            if (input.isConditional()) {
+                for (const rule of input.conditionalRules ?? []) {
+                    /**
+                     * Add the conditional input to the conditional fields lists
+                     */
+                    if (!_conditionalFieldMap.has(rule.field.name)) {
+                        _conditionalFieldMap.set(rule.field.name, []);
+                    }
+                    _conditionalFieldMap.get(rule.field.name).push(
+                    /**
+                     * Clone the conditional field to avoid reference issues
+                     */
+                    cloneDeep({
+                        field: input.exportForClient(),
+                        rule: {
+                            condition: rule.condition,
+                            value: rule.value,
+                        },
+                    }));
+                }
+            }
+        }
+        /**
+         * Assign conditionalFields to the appropriate fields
+         */
+        for (const field of this._sectionInfo.fields) {
+            const matchingConditionalFields = _conditionalFieldMap.get(field.name);
+            if (matchingConditionalFields) {
+                field.conditionalFields.push(...matchingConditionalFields.map((clonedConditionalField) => ({
+                    ...clonedConditionalField,
+                    rule: {
+                        condition: clonedConditionalField.rule.condition,
+                        value: clonedConditionalField.rule.value,
+                    },
+                })));
+            }
+        }
+        /**
+         * Destroy the map
+         */
+        _conditionalFieldMap.clear();
+    }
+    /**
+     * Sort fields by their order property, preserving original position for fields without order.
+     *
+     * Sorting behavior:
+     * 1. Fields with explicit `order` values are sorted by that value (ascending)
+     * 2. Fields without `order` maintain their original array position (stable sort)
+     * 3. Fields with the same `order` value maintain their relative positions (stable sort)
+     *
+     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
+     * Note: This mutates the input array for performance.
+     *
+     * @param fields - Array of fields to sort (will be mutated)
+     * @returns The sorted array (same reference as input)
+     * @private
+     */
+    sortFieldsByOrder(fields) {
+        // Sort in-place for performance (mutates array)
+        // JavaScript's sort is stable (ES2019+), so equal values maintain original order
+        return fields.sort((a, b) => (a.order ?? FieldFactory.DEFAULT_ORDER) - (b.order ?? FieldFactory.DEFAULT_ORDER));
+    }
+    /**
+     * Sort groups by their groupOrder property, preserving original position for groups without order.
+     *
+     * Sorting behavior:
+     * 1. Groups with explicit `groupOrder` values are sorted by that value (ascending)
+     * 2. Groups without `groupOrder` maintain their original array position (stable sort)
+     * 3. Groups with the same `groupOrder` value maintain their relative positions (stable sort)
+     *
+     * This leverages JavaScript's stable Array.sort() (ES2019+) for optimal performance.
+     * Note: This mutates the input array for performance.
+     * Note: groupOrder is normalized at creation time, so no nullish coalescing needed here.
+     *
+     * @param groups - Array of groups to sort (will be mutated)
+     * @returns The sorted array (same reference as input)
+     * @private
+     */
+    sortGroupsByOrder(groups) {
+        // Sort in-place for performance (mutates array)
+        // JavaScript's sort is stable (ES2019+), so equal values maintain original order
+        // groupOrder is normalized at creation time, so direct subtraction is safe
+        return groups.sort((a, b) => a.groupOrder - b.groupOrder);
+    }
+    /**
+     * Get field groups with filtered and sorted fields.
+     * Leverages the pre-built fieldGroups from the Section class for better performance.
+     */
+    getGroupedFields() {
+        if (this._error)
+            return;
+        if (!this._sectionInfo)
+            return;
+        const fieldGroups = this._sectionInfo.fieldGroups;
+        const isNewOperation = this.type === 'new';
+        const isEditOperation = this.type === 'edit';
+        const isCategorySection = is(this._sectionInfo, CategorySection);
+        // Build groups in a single pass, skipping empty groups
+        const processedGroups = [];
+        for (let i = 0, len = fieldGroups.length; i < len; i++) {
+            const group = fieldGroups[i];
+            if (!group)
+                continue;
+            const fields = group.fields;
+            const validFields = [];
+            // Filter and collect valid fields in one pass
+            for (let j = 0, fieldLen = fields.length; j < fieldLen; j++) {
+                const field = fields[j];
+                if (!field)
+                    continue;
+                // Skip conditional fields (they're nested in their parent field)
+                if (field.isConditional())
+                    continue;
+                // For new item operations, exclude fields with adminGenerated not set to true
+                if (isNewOperation && field.adminGenerated !== true)
+                    continue;
+                // For edit operations, exclude fields with adminGenerated set to false
+                if (isEditOperation && field.adminGenerated === false)
+                    continue;
+                // For category sections, exclude parent_id and level fields
+                if (isCategorySection && (field.name === 'parent_id' || field.name === 'level'))
+                    continue;
+                /**
+                 * Add the field to the valid fields array
+                 */
+                validFields.push(field);
+            }
+            /**
+             * Only return the group if it has valid fields
+             */
+            if (validFields.length > 0) {
+                processedGroups.push({
+                    groupId: group.id,
+                    groupTitle: group.title ?? '',
+                    // Normalize order value here to avoid checking again in sort function
+                    groupOrder: group.order ?? FieldFactory.DEFAULT_ORDER,
+                    inputs: this.sortFieldsByOrder(validFields).map((field) => field.exportForClient()),
+                });
+            }
+        }
+        // Sort groups by order using the optimized function
+        this.sortGroupsByOrder(processedGroups);
+        /**
+         * Unset the section info to be garbage collected
+         */
+        this._sectionInfo = null;
+        return processedGroups;
+    }
+    get sectionInfo() {
+        return this._sectionInfo ?? undefined;
+    }
+    get errorMessage() {
+        return this._errorMessage;
+    }
+    get error() {
+        return this._error;
+    }
+}