@jd-data-limited/easy-fm 4.0.14 → 4.1.0

package/src/records/layoutRecord.js

@@ -1,13 +1,12 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { RecordBase } from "./recordBase.js";
-import { PortalRecord } from "./portalRecord.js";
-import { Portal } from "./portal.js";
-import { FMError } from "../FMError.js";
-import * as moment from "moment/moment.js";
+import { RecordBase } from './recordBase.js';
+import { PortalRecord } from './portalRecord.js';
+import { Portal } from './portal.js';
+import { FMError } from '../FMError.js';
+import * as moment from 'moment/moment.js';
 export class LayoutRecord extends RecordBase {
-    // @ts-ignore
     portals = {};
     portalsToInclude;
     constructor(layout, recordId, modId = recordId, fieldData = {}, portalData = null, portalsToInclude = []) {
@@ -20,38 +19,44 @@ export class LayoutRecord extends RecordBase {
     get portalsArray() {
         return Object.values(this.portals);
     }
+    /**
+     * Asynchronously commits the changes made to the current record.
+     * @param {extraBodyOptions} extraBody - The options for the extra body elements.
+     * @returns {Promise<this>} - A promise that resolves with the modified object.
+     * @throws {FMError} - If an error occurs during the commit process.
+     */
     async commit(extraBody = {}) {
-        let data = this.toObject();
+        const data = this.toObject();
         delete data.recordId;
         delete data.modId;
         if (extraBody.scripts?.after) {
-            data["script"] = extraBody.scripts.after.name;
+            data.script = extraBody.scripts.after.name;
             if (extraBody.scripts.after.parameter)
-                data["script.param"] = extraBody.scripts.after.parameter;
+                data['script.param'] = extraBody.scripts.after.parameter;
         }
         if (extraBody.scripts?.prerequest) {
-            data["script.prerequest"] = extraBody.scripts.prerequest.name;
+            data['script.prerequest'] = extraBody.scripts.prerequest.name;
             if (extraBody.scripts.prerequest.parameter)
-                data["script.prerequest.param"] = extraBody.scripts.prerequest.parameter;
+                data['script.prerequest.param'] = extraBody.scripts.prerequest.parameter;
         }
         if (extraBody.scripts?.presort) {
-            data["script.presort"] = extraBody.scripts.presort.name;
+            data['script.presort'] = extraBody.scripts.presort.name;
             if (extraBody.scripts.presort.parameter)
-                data["script.presort.param"] = extraBody.scripts.presort.parameter;
+                data['script.presort.param'] = extraBody.scripts.presort.parameter;
         }
         if (this.recordId === -1) {
             // This is a new LayoutRecord
-            let res = await this.layout.database.apiRequestJSON(`${this.layout.endpoint}/records`, {
-                method: "POST",
+            const res = await this.layout.database._apiRequestJSON(`${this.layout.endpoint}/records`, {
+                method: 'POST',
                 body: JSON.stringify(data)
             });
             if (!res.response) {
                 throw new FMError(res.messages[0].code, res.httpStatus, res);
             }
-            else if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+            else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
                 throw new FMError(res.response.scriptError, res.httpStatus, res);
             }
-            else if (res.messages[0].code === "0") {
+            else if (res.messages[0].code === '0') {
                 this.recordId = parseInt(res.response.recordId);
                 this.modId = parseInt(res.response.modId);
                 return this;
@@ -61,17 +66,17 @@ export class LayoutRecord extends RecordBase {
             }
         }
         // for (let item of Object.keys(data)) extraBody[item] = data[item]
-        let res = await this.layout.database.apiRequestJSON(this.endpoint, {
-            method: "PATCH",
+        const res = await this.layout.database._apiRequestJSON(this.endpoint, {
+            method: 'PATCH',
             body: JSON.stringify(data)
         });
         if (!res.response) {
             throw new FMError(res.messages[0].code, res.httpStatus, res);
         }
-        else if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+        else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res);
         }
-        else if (res.messages[0].code === "0") {
+        else if (res.messages[0].code === '0') {
             this.modId = +res.response.modId;
             this._onSave();
             return this;
@@ -81,29 +86,36 @@ export class LayoutRecord extends RecordBase {
         }
     }
     processPortalData(portalData) {
-        for (let portalName of Object.keys(portalData)) {
-            let _portal = new Portal(this, portalName);
+        for (const portalName of Object.keys(portalData)) {
+            const _portal = new Portal(this, portalName);
             _portal.records = portalData[portalName].map(item => {
-                let fieldData = item;
+                const fieldData = item;
                 delete fieldData.recordId;
                 delete fieldData.modId;
                 return new PortalRecord(this, _portal, parseInt(item.recordId), parseInt(item.modId), fieldData);
             });
-            // @ts-ignore
+            // @ts-expect-error - This code is actually correct, but throws a typescript error
             this.portals[portalName] = _portal;
         }
     }
+    /**
+     * Re-fetches the current record from the database server.
+     * Throws an error if commit() has not been called.
+     *
+     * @return {Promise<this>} A Promise that resolves to this RecordBase instance if the record is successfully retrieved.
+     * @throws {Error} If commit() has not been called.
+     * @throws {FMError} If the retrieval fails.
+     */
     async get() {
-        let trace = new Error();
         if (this.recordId === -1) {
-            throw "Cannot get this RecordBase until a commit() is done.";
+            throw new Error('Cannot get this RecordBase until a commit() is done.');
         }
         if (!this.layout.metadata)
             await this.layout.getLayoutMeta();
-        let res = await this.layout.database.apiRequestJSON(this.endpoint, {
-            method: "GET"
+        const res = await this.layout.database._apiRequestJSON(this.endpoint, {
+            method: 'GET'
         });
-        if (res.response && res.messages[0].code === "0") {
+        if (res.response && res.messages[0].code === '0') {
             // console.log(res, res.response.data)
             this.modId = +res.response.data[0].modId;
             this.processFieldData(res.response.data[0].fieldData);
@@ -117,20 +129,20 @@ export class LayoutRecord extends RecordBase {
         }
     }
     async duplicate() {
-        let trace = new Error();
-        let res = await this.layout.database.apiRequestJSON(this.endpoint, {
-            method: "POST"
+        const trace = new Error();
+        const res = await this.layout.database._apiRequestJSON(this.endpoint, {
+            method: 'POST'
         });
         if (!res.response) {
             throw new FMError(res.messages[0].code, res.httpStatus, res, trace);
         }
-        else if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+        else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res, trace);
         }
-        else if (res.messages[0].code === "0") {
-            let data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false);
-            let _res = new LayoutRecord(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData);
-            this.emit("duplicated");
+        else if (res.messages[0].code === '0') {
+            const data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false);
+            const _res = new LayoutRecord(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData);
+            this.emit('duplicated');
             return _res;
         }
         else {
@@ -138,63 +150,61 @@ export class LayoutRecord extends RecordBase {
         }
     }
     async delete() {
-        let res = await this.layout.database.apiRequestJSON(this.endpoint, {
-            method: "DELETE"
+        const res = await this.layout.database._apiRequestJSON(this.endpoint, {
+            method: 'DELETE'
         });
         console.log(res);
-        if (typeof res.response?.scriptError !== "undefined" && res.response?.scriptError !== '0') {
+        if (typeof res.response?.scriptError !== 'undefined' && res.response?.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res);
         }
-        else if (res.messages[0].code === "0") {
-            this.emit("deleted");
-            return;
+        else if (res.messages[0].code === '0') {
+            this.emit('deleted');
         }
         else {
             throw new FMError(res.messages[0].code, res.httpStatus, res);
         }
     }
     fieldsToObject(filter = (a) => a.edited) {
-        let fields_processed = {};
+        const fields_processed = {};
         let field;
         for (field of this.fieldsArray.filter(field => filter(field))) {
             let value = field.value;
             if (value instanceof Date) {
-                // @ts-ignore
-                let _value = moment.default(value)
-                    .utcOffset(this.layout.database.host.timezoneOffset);
-                // @ts-ignore
+                let _value = moment.default(value);
+                _value = _value
+                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value));
                 switch (field.metadata.result) {
-                    case "time":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"));
+                    case 'time':
+                        value = _value.format(this.layout.database.host.timeFormat);
                         break;
-                    case "date":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"));
+                    case 'date':
+                        value = _value.format(this.layout.database.host.dateFormat);
                         break;
                     default:
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"));
+                        value = _value.format(this.layout.database.host.timeStampFormat);
                 }
             }
             fields_processed[field.id] = value;
         }
-        let obj = {
-            "recordId": this.recordId.toString(),
-            "modId": this.modId.toString(),
-            "fieldData": fields_processed
+        const obj = {
+            recordId: this.recordId.toString(),
+            modId: this.modId.toString(),
+            fieldData: fields_processed
         };
         return obj;
     }
     toObject(filter = (a) => a.edited, portalFilter = (a) => a.records.find(record => record.edited), portalRowFilter = (a) => a.edited, portalFieldFilter = (a) => a.edited) {
-        let obj = {
+        const obj = {
             ...this.fieldsToObject(filter),
-            portalData: {},
+            portalData: {}
         };
         // Check if there's been any edited portal information
-        let portals = this.portalsArray.filter(a => portalFilter(a));
+        const portals = this.portalsArray.filter(a => portalFilter(a));
         if (portals) {
-            obj["portalData"] = {};
-            for (let portal of portals) {
-                // @ts-ignore
-                obj["portalData"][portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
+            obj.portalData = {};
+            for (const portal of portals) {
+                // @ts-expect-error
+                obj.portalData[portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
                     return record.toObject(portalFieldFilter);
                 });
             }

package/src/records/layoutRecord.ts

@@ -2,135 +2,146 @@
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
 
-import {extraBodyOptions} from "../types.js";
-import {RecordBase} from "./recordBase.js";
-import {PortalRecord} from "./portalRecord.js";
-import {Portal} from "./portal.js";
-import {LayoutInterface} from "../layouts/layoutInterface.js";
-import {FMError} from "../FMError.js";
-import {LayoutRecordBase} from "./layoutRecordBase.js";
-import {ApiFieldData, ApiPortalData, ApiRecordResponseObj, ApiRowDataDef} from "../models/apiResults.js";
-import {LayoutBase} from "../layouts/layoutBase.js"
-import * as moment from "moment/moment.js";
-import {Field, FieldValue} from "./field.js";
-
-export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT["fields"]> implements LayoutRecordBase {
-    // @ts-ignore
-    portals: LAYOUT["portals"] = {}
-    private readonly portalsToInclude: (string | number | symbol)[]
-
-    constructor(
+import {type extraBodyOptions} from '../types.js'
+import {RecordBase} from './recordBase.js'
+import {PortalRecord} from './portalRecord.js'
+import {Portal} from './portal.js'
+import {type LayoutInterface} from '../layouts/layoutInterface.js'
+import {FMError} from '../FMError.js'
+import {type LayoutRecordBase} from './layoutRecordBase.js'
+import {
+    type ApiFieldData,
+    type ApiPortalData,
+    type ApiRecordResponseObj,
+    type ApiRowDataDef
+} from '../models/apiResults.js'
+import {type LayoutBase} from '../layouts/layoutBase.js'
+import * as moment from 'moment/moment.js'
+import {type Field, type FieldValue} from './field.js'
+
+export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAYOUT['fields']> implements LayoutRecordBase {
+    portals: LAYOUT['portals'] = {}
+    private readonly portalsToInclude: Array<string | number | symbol>
+
+    constructor (
         layout: LayoutBase,
         recordId: number | string,
         modId = recordId,
         fieldData: Record<string, string | number> = {},
-        portalData: ApiPortalData | null = null, portalsToInclude: (keyof LAYOUT["portals"])[] = [])
-    {
-        super(layout, parseInt(recordId as string), parseInt(modId as string), fieldData);
+        portalData: ApiPortalData | null = null, portalsToInclude: Array<keyof LAYOUT['portals']> = []) {
+        super(layout, parseInt(recordId as string), parseInt(modId as string), fieldData)
         this.portalsToInclude = portalsToInclude
         if (portalData) {
             this.processPortalData(portalData)
         }
     }
 
-    get portalsArray(): Portal<any>[] {
+    get portalsArray (): Array<Portal<any>> {
         return Object.values(this.portals)
     }
 
-    async commit(extraBody: extraBodyOptions = {}): Promise<this> {
-        let data: any = this.toObject()
+    /**
+     * Asynchronously commits the changes made to the current record.
+     * @param {extraBodyOptions} extraBody - The options for the extra body elements.
+     * @returns {Promise<this>} - A promise that resolves with the modified object.
+     * @throws {FMError} - If an error occurs during the commit process.
+     */
+    async commit (extraBody: extraBodyOptions = {}): Promise<this> {
+        const data: any = this.toObject()
         delete data.recordId
         delete data.modId
 
         if (extraBody.scripts?.after) {
-            data["script"] = extraBody.scripts.after.name
-            if (extraBody.scripts.after.parameter) data["script.param"] = extraBody.scripts.after.parameter
+            data.script = extraBody.scripts.after.name
+            if (extraBody.scripts.after.parameter) data['script.param'] = extraBody.scripts.after.parameter
         }
         if (extraBody.scripts?.prerequest) {
-            data["script.prerequest"] = extraBody.scripts.prerequest.name
-            if (extraBody.scripts.prerequest.parameter) data["script.prerequest.param"] = extraBody.scripts.prerequest.parameter
+            data['script.prerequest'] = extraBody.scripts.prerequest.name
+            if (extraBody.scripts.prerequest.parameter) data['script.prerequest.param'] = extraBody.scripts.prerequest.parameter
         }
         if (extraBody.scripts?.presort) {
-            data["script.presort"] = extraBody.scripts.presort.name
-            if (extraBody.scripts.presort.parameter) data["script.presort.param"] = extraBody.scripts.presort.parameter
+            data['script.presort'] = extraBody.scripts.presort.name
+            if (extraBody.scripts.presort.parameter) data['script.presort.param'] = extraBody.scripts.presort.parameter
         }
 
         if (this.recordId === -1) {
             // This is a new LayoutRecord
-             let res = await this.layout.database.apiRequestJSON<{ recordId: string, modId: string }>(`${this.layout.endpoint}/records`, {
-                    method: "POST",
-                    body: JSON.stringify(data)
-                })
+            const res = await this.layout.database._apiRequestJSON<{ recordId: string, modId: string }>(`${this.layout.endpoint}/records`, {
+                method: 'POST',
+                body: JSON.stringify(data)
+            })
 
-                if (!res.response) {
-                    throw new FMError(res.messages[0].code, res.httpStatus, res)
-                }
-                else if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
-                    throw new FMError(res.response.scriptError, res.httpStatus, res)
-                }
-                else if (res.messages[0].code === "0") {
-                    this.recordId = parseInt(res.response.recordId)
-                    this.modId = parseInt(res.response.modId)
-                    return this
-                }
-                else {
-                    throw new FMError(res.messages[0].code, res.httpStatus, res)
-                }
+            if (!res.response) {
+                throw new FMError(res.messages[0].code, res.httpStatus, res)
+            } else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
+                throw new FMError(res.response.scriptError, res.httpStatus, res)
+            } else if (res.messages[0].code === '0') {
+                this.recordId = parseInt(res.response.recordId)
+                this.modId = parseInt(res.response.modId)
+                return this
+            } else {
+                throw new FMError(res.messages[0].code, res.httpStatus, res)
+            }
         }
 
         // for (let item of Object.keys(data)) extraBody[item] = data[item]
-        let res = await this.layout.database.apiRequestJSON<{
-            modId: string, newPortalRecordInfo: {
-                tableName: string,
-                recordId: string,
+        const res = await this.layout.database._apiRequestJSON<{
+            modId: string,
+            newPortalRecordInfo: Array<{
+                tableName: string
+                recordId: string
                 modId: string
-            }[]
+            }>
         }>(this.endpoint, {
-            method: "PATCH",
+            method: 'PATCH',
             body: JSON.stringify(data)
         })
         if (!res.response) {
             throw new FMError(res.messages[0].code, res.httpStatus, res)
-        }
-        else if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+        } else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res)
-        }
-        else if (res.messages[0].code === "0") {
+        } else if (res.messages[0].code === '0') {
             this.modId = +res.response.modId
             this._onSave()
             return this
-        }
-        else {
+        } else {
             throw new FMError(res.messages[0].code, res.httpStatus, res)
         }
     }
 
-    protected processPortalData(portalData: ApiPortalData): void {
-        for (let portalName of Object.keys(portalData)) {
-            let _portal = new Portal(this, portalName)
+    protected processPortalData (portalData: ApiPortalData): void {
+        for (const portalName of Object.keys(portalData)) {
+            const _portal = new Portal(this, portalName)
             _portal.records = portalData[portalName].map(item => {
-                let fieldData = item;
-                delete fieldData.recordId;
-                delete fieldData.modId;
-                return new PortalRecord(this, _portal, parseInt(item.recordId as string), parseInt(item.modId as string), fieldData);
+                const fieldData = item
+                delete fieldData.recordId
+                delete fieldData.modId
+                return new PortalRecord(this, _portal, parseInt(item.recordId as string), parseInt(item.modId as string), fieldData)
             })
 
-            // @ts-ignore
-            this.portals[portalName] = _portal;
+            // @ts-expect-error - This code is actually correct, but throws a typescript error
+            this.portals[portalName] = _portal
         }
     }
 
-    async get(): Promise<this> {
-        let trace = new Error()
+    /**
+     * Re-fetches the current record from the database server.
+     * Throws an error if commit() has not been called.
+     *
+     * @return {Promise<this>} A Promise that resolves to this RecordBase instance if the record is successfully retrieved.
+     * @throws {Error} If commit() has not been called.
+     * @throws {FMError} If the retrieval fails.
+     */
+    async get (): Promise<this> {
         if (this.recordId === -1) {
-            throw "Cannot get this RecordBase until a commit() is done."
+            throw new Error('Cannot get this RecordBase until a commit() is done.')
         }
         if (!this.layout.metadata) await this.layout.getLayoutMeta()
-        let res = await this.layout.database.apiRequestJSON<ApiRecordResponseObj>(this.endpoint, {
-            method: "GET"
+        const res = await this.layout.database._apiRequestJSON<ApiRecordResponseObj>(this.endpoint, {
+            method: 'GET'
         })
 
-        if (res.response && res.messages[0].code === "0") {
+        if (res.response && res.messages[0].code === '0') {
             // console.log(res, res.response.data)
             this.modId = +res.response.data[0].modId
             this.processFieldData(res.response.data[0].fieldData)
@@ -142,97 +153,89 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
         }
     }
 
-    async duplicate(): Promise<LayoutRecord<LAYOUT>> {
-        let trace = new Error()
-        let res = await this.layout.database.apiRequestJSON<{recordId: string, modId: string}>(this.endpoint, {
-            method: "POST"
+    async duplicate (): Promise<LayoutRecord<LAYOUT>> {
+        const trace = new Error()
+        const res = await this.layout.database._apiRequestJSON<{ recordId: string, modId: string }>(this.endpoint, {
+            method: 'POST'
         })
         if (!res.response) {
             throw new FMError(res.messages[0].code, res.httpStatus, res, trace)
-        }
-        else if (typeof res.response.scriptError !== "undefined" && res.response.scriptError !== '0') {
+        } else if (typeof res.response.scriptError !== 'undefined' && res.response.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res, trace)
-        }
-        else if (res.messages[0].code === "0") {
-            let data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false)
-            let _res = new LayoutRecord<LAYOUT>(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData)
+        } else if (res.messages[0].code === '0') {
+            const data = this.toObject((a) => true, (a) => true, (a) => false, (a) => false)
+            const _res = new LayoutRecord<LAYOUT>(this.layout, res.response.recordId, res.response.modId, data.fieldData, data.portalData)
 
-            this.emit("duplicated")
+            this.emit('duplicated')
             return _res
-        }
-        else {
+        } else {
             throw new FMError(res.messages[0].code, res.httpStatus, res, trace)
         }
     }
 
-    async delete(): Promise<void> {
-        let res = await this.layout.database.apiRequestJSON(this.endpoint, {
-            method: "DELETE"
+    async delete (): Promise<void> {
+        const res = await this.layout.database._apiRequestJSON(this.endpoint, {
+            method: 'DELETE'
         })
         console.log(res)
-        if (typeof res.response?.scriptError !== "undefined" && res.response?.scriptError !== '0') {
+        if (typeof res.response?.scriptError !== 'undefined' && res.response?.scriptError !== '0') {
             throw new FMError(res.response.scriptError, res.httpStatus, res)
-        }
-        else if (res.messages[0].code === "0") {
-            this.emit("deleted")
-            return
-        }
-        else {
+        } else if (res.messages[0].code === '0') {
+            this.emit('deleted')
+        } else {
             throw new FMError(res.messages[0].code, res.httpStatus, res)
         }
     }
 
-    fieldsToObject(filter = (a: Field<FieldValue>) => a.edited): Omit<ApiRowDataDef, "portalData"> {
-        let fields_processed: ApiFieldData = {}
+    fieldsToObject (filter = (a: Field<FieldValue>) => a.edited): Omit<ApiRowDataDef, 'portalData'> {
+        const fields_processed: ApiFieldData = {}
         let field: Field<FieldValue>
         for (field of this.fieldsArray.filter(field => filter(field))) {
             let value = field.value as string | number | Date
             if (value instanceof Date) {
-                // @ts-ignore
                 let _value = moment.default(value)
-                    .utcOffset(this.layout.database.host.timezoneOffset)
-
-                // @ts-ignore
+                _value = _value
+                    .utcOffset(this.layout.database.host.timezoneOffsetFunc(_value))
 
                 switch (field.metadata.result) {
-                    case "time":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeFormat.replace("dd", "DD"))
+                    case 'time':
+                        value = _value.format(this.layout.database.host.timeFormat)
                         break
-                    case "date":
-                        value = _value.format(this.layout.database.host.metadata.productInfo.dateFormat.replace("dd", "DD"))
+                    case 'date':
+                        value = _value.format(this.layout.database.host.dateFormat)
                         break
                     default:
-                        value = _value.format(this.layout.database.host.metadata.productInfo.timeStampFormat.replace("dd", "DD"))
+                        value = _value.format(this.layout.database.host.timeStampFormat)
                 }
             }
             fields_processed[field.id] = value
         }
-        let obj = {
-            "recordId": this.recordId.toString(),
-            "modId": this.modId.toString(),
-            "fieldData": fields_processed
+        const obj = {
+            recordId: this.recordId.toString(),
+            modId: this.modId.toString(),
+            fieldData: fields_processed
         }
         return obj
     }
 
-    toObject(
+    toObject (
         filter: (a: Field<FieldValue>) => any = (a) => a.edited,
         portalFilter: (a: Portal<any>) => any = (a) => a.records.find(record => record.edited),
         portalRowFilter: (a: PortalRecord<never>) => any = (a) => a.edited,
         portalFieldFilter: (a: Field<FieldValue>) => any = (a) => a.edited
     ) {
-        let obj: ApiRowDataDef = {
+        const obj: ApiRowDataDef = {
             ...this.fieldsToObject(filter),
-            portalData: {},
-        };
+            portalData: {}
+        }
 
         // Check if there's been any edited portal information
-        let portals = this.portalsArray.filter(a => portalFilter(a))
+        const portals = this.portalsArray.filter(a => portalFilter(a))
         if (portals) {
-            obj["portalData"] = {}
-            for (let portal of portals) {
-                // @ts-ignore
-                obj["portalData"][portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
+            obj.portalData = {}
+            for (const portal of portals) {
+                // @ts-expect-error
+                obj.portalData[portal.name] = portal.records.filter(a => portalRowFilter(a)).map(record => {
                     return record.toObject(portalFieldFilter)
                 })
             }
@@ -240,4 +243,4 @@ export class LayoutRecord<LAYOUT extends LayoutInterface> extends RecordBase<LAY
 
         return obj
     }
-}
+}

package/src/records/layoutRecordBase.d.ts

@@ -1,5 +1,5 @@
-import { LayoutBase } from "../layouts/layoutBase.js";
+import { type LayoutBase } from '../layouts/layoutBase.js';
 export interface LayoutRecordBase {
     layout: LayoutBase;
-    commit(extraBody: object): Promise<this>;
+    commit: (extraBody: object) => Promise<this>;
 }