@finsys/core 1.0.1 → 1.1.0

package/dist/form-field.js

@@ -0,0 +1,197 @@
+export var FieldType;
+(function (FieldType) {
+    FieldType["FILE"] = "file";
+    FieldType["TEXT"] = "text";
+    FieldType["DROPDOWN"] = "dropdown";
+    FieldType["BOOLEAN"] = "boolean";
+    FieldType["CHECKBOX"] = "checkbox";
+    FieldType["RADIOGROUP"] = "radiogroup";
+    FieldType["SLIDER"] = "slider";
+    FieldType["HTML"] = "html";
+    FieldType["TAGBOX"] = "tagbox";
+    FieldType["NUMBER"] = "number";
+    FieldType["EMAIL"] = "email";
+    FieldType["COMMENT"] = "comment";
+    FieldType["RANGE"] = "range";
+    FieldType["UNKNOWN"] = "unknown";
+})(FieldType || (FieldType = {}));
+function toFieldType(value) {
+    const typeMap = {
+        [FieldType.FILE]: FieldType.FILE,
+        [FieldType.TEXT]: FieldType.TEXT,
+        [FieldType.DROPDOWN]: FieldType.DROPDOWN,
+        [FieldType.BOOLEAN]: FieldType.BOOLEAN,
+        [FieldType.CHECKBOX]: FieldType.CHECKBOX,
+        [FieldType.RADIOGROUP]: FieldType.RADIOGROUP,
+        [FieldType.SLIDER]: FieldType.SLIDER,
+        [FieldType.HTML]: FieldType.HTML,
+        [FieldType.TAGBOX]: FieldType.TAGBOX,
+        [FieldType.NUMBER]: FieldType.NUMBER,
+        [FieldType.EMAIL]: FieldType.EMAIL,
+        [FieldType.COMMENT]: FieldType.COMMENT,
+        [FieldType.RANGE]: FieldType.RANGE,
+    };
+    return typeMap[value] || FieldType.UNKNOWN;
+}
+export default class FormField {
+    constructor(name, displayName, type, category) {
+        this.fieldObject = {
+            name,
+            displayName,
+            type,
+            category,
+        };
+    }
+    static fromObject(fieldObject) {
+        if (!fieldObject.name) {
+            throw new Error('Field name is required');
+        }
+        if (!fieldObject.displayName || !fieldObject.category) {
+            throw new Error(`Invalid field object: '${fieldObject.name}' field missing displayName or category`);
+        }
+        const identifiedType = toFieldType(fieldObject.type);
+        if (identifiedType === FieldType.UNKNOWN) {
+            throw new Error(`'${fieldObject.name}' field has unsupported or missing type: ${fieldObject.type}`);
+        }
+        if (fieldObject.choices &&
+            !['dropdown', 'checkbox', 'radiogroup', 'tagbox'].includes(fieldObject.type)) {
+            // Logic remained as is
+        }
+        if (fieldObject.type === 'dropdown' && !fieldObject.choices) {
+            throw new Error(`Invalid field object: '${fieldObject.name}' field has type dropdown, but does not have choices`);
+        }
+        let field;
+        if (fieldObject.type === 'file') {
+            field = new FileFormField(fieldObject.name, fieldObject.displayName || fieldObject.name, fieldObject.type, String(fieldObject.category), fieldObject.ihs_column_names || []);
+        }
+        else {
+            field = new BasicFormField(fieldObject.name, fieldObject.displayName || fieldObject.name, fieldObject.type || 'text', String(fieldObject.category));
+        }
+        field.fieldObject = { ...fieldObject };
+        field.fieldObject.category = String(field.fieldObject.category);
+        // Remove legacy categoryId property
+        delete field.fieldObject.categoryId;
+        return field;
+    }
+    cleanObject(obj) {
+        if (obj === null || obj === undefined)
+            return obj;
+        let target = obj;
+        if (typeof obj.toJSON === 'function' && obj !== this) {
+            target = obj.toJSON();
+        }
+        if (Array.isArray(target)) {
+            return target.map((v) => (typeof v === 'object' ? this.cleanObject(v) : v));
+        }
+        if (typeof target !== 'object')
+            return target;
+        const cleaned = {};
+        Object.keys(target).forEach((key) => {
+            const value = target[key];
+            if (value !== null && value !== undefined && value !== '') {
+                if (typeof value === 'object') {
+                    cleaned[key] = this.cleanObject(value);
+                }
+                else {
+                    cleaned[key] = value;
+                }
+            }
+        });
+        return cleaned;
+    }
+    toJSON() {
+        return this.cleanObject({ ...this.fieldObject });
+    }
+    get displayName() {
+        return this.fieldObject.displayName || this.fieldObject.name || '';
+    }
+    set displayName(newDisplayName) {
+        this.fieldObject.displayName = newDisplayName;
+    }
+    get name() {
+        return this.fieldObject.name || '';
+    }
+    get type() {
+        return toFieldType(this.fieldObject.type);
+    }
+    get inputType() {
+        return this.fieldObject.inputType ?? '';
+    }
+    get categoryId() {
+        return String(this.fieldObject.category || '');
+    }
+    set categoryId(categoryId) {
+        this.fieldObject.category = categoryId;
+    }
+    get defaultValue() {
+        return this.fieldObject.defaultValue;
+    }
+    set defaultValue(value) {
+        this.fieldObject.defaultValue = value;
+    }
+    get placeholder() {
+        return this.fieldObject.placeholder;
+    }
+    get validators() {
+        return this.fieldObject.validators;
+    }
+    get choices() {
+        return this.fieldObject.choices ?? [];
+    }
+    set choices(choices) {
+        this.fieldObject.choices = choices;
+    }
+    get visible() {
+        return this.fieldObject.visible ?? true;
+    }
+    get visibleIf() {
+        return this.fieldObject.visibleIf;
+    }
+    get isRequired() {
+        return this.fieldObject.required ?? this.fieldObject.isRequired ?? true;
+    }
+    get startWithNewLine() {
+        return this.fieldObject.startWithNewLine ?? true;
+    }
+    get requiredForEvaluation() {
+        return this.fieldObject.requiredForEvaluation ?? true;
+    }
+    get maxLength() {
+        return typeof this.fieldObject.maxLength === 'string'
+            ? Number.parseInt(this.fieldObject.maxLength)
+            : this.fieldObject.maxLength;
+    }
+    get min() {
+        return typeof this.fieldObject.min === 'string'
+            ? Number.parseFloat(this.fieldObject.min)
+            : this.fieldObject.min;
+    }
+    get max() {
+        return typeof this.fieldObject.max === 'string'
+            ? Number.parseFloat(this.fieldObject.max)
+            : this.fieldObject.max;
+    }
+}
+export class BasicFormField extends FormField {
+    constructor(name, displayName, type, category) {
+        super(name, displayName, type, category);
+    }
+    getFieldNames() {
+        if (this.fieldObject.requiredForEvaluation === false) {
+            return [];
+        }
+        return [this.fieldObject.name];
+    }
+}
+export class FileFormField extends FormField {
+    constructor(name, displayName, type, category, ihs_column_names) {
+        super(name, displayName, type, category);
+        this.fieldObject.ihs_column_names = ihs_column_names;
+    }
+    getFieldNames() {
+        if (this.fieldObject.requiredForEvaluation === false) {
+            return [];
+        }
+        return this.fieldObject.ihs_column_names || [];
+    }
+}

package/dist/form-field.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/form-field.test.js

@@ -0,0 +1,482 @@
+import { describe, it, expect } from "vitest";
+import FormField, { BasicFormField, FileFormField, FieldType, } from "./form-field.js";
+const basicField = {
+    name: "email",
+    displayName: "Test",
+    type: "text",
+    inputType: "text",
+    category: "1",
+};
+const fileField = {
+    name: "test",
+    displayName: "Test",
+    type: "file",
+    inputType: "text",
+    category: "1",
+    ihs_column_names: ["idNumber", "companyName"],
+};
+describe("FormField", () => {
+    it("creates basic field from object", () => {
+        const formField = FormField.fromObject(basicField);
+        const names = formField.getFieldNames();
+        expect(names[0]).toBe("email");
+    });
+    it("creates file field from object", () => {
+        const formField = FormField.fromObject(fileField);
+        const names = formField.getFieldNames();
+        expect(names[0]).toBe("idNumber");
+        expect(names[1]).toBe("companyName");
+    });
+    it("gets displayName", () => {
+        const formField = FormField.fromObject(basicField);
+        expect(formField.displayName).toBe("Test");
+    });
+    it("gets name", () => {
+        const formField = FormField.fromObject(basicField);
+        expect(formField.name).toBe("email");
+    });
+    it("sets displayName", () => {
+        const formField = FormField.fromObject({ ...basicField });
+        formField.displayName = "New Display Name";
+        expect(formField.displayName).toBe("New Display Name");
+    });
+    it("gets visible with true value", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            visible: true,
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.visible).toBe(true);
+    });
+    it("gets visible with undefined value defaults to true", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.visible).toBe(true);
+    });
+    it("gets visibleIf", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            visibleIf: '{test} == "test"',
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.visibleIf).toBe('{test} == "test"');
+    });
+    it("gets isRequired", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            isRequired: true,
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.isRequired).toBe(true);
+    });
+    it("gets type", () => {
+        const formField = FormField.fromObject(basicField);
+        expect(formField.type).toBe("text");
+    });
+    it("gets type for various field types", () => {
+        const types = ["text", "file", "dropdown"];
+        for (const type of types) {
+            const fieldObject = {
+                name: "test",
+                displayName: "Test Field",
+                type: type,
+                category: "1",
+                ...(type === "dropdown"
+                    ? { choices: [{ text: "Option", value: "1" }] }
+                    : {}),
+            };
+            const formField = FormField.fromObject(fieldObject);
+            expect(formField.type).toBe(type);
+        }
+    });
+    it("gets inputType with defined inputType", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test Field",
+            type: "text",
+            inputType: "email",
+            category: "1",
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.inputType).toBe("email");
+    });
+    it("gets inputType with undefined inputType returns empty string", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test Field",
+            type: "text",
+            category: "1",
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.inputType).toBe("");
+    });
+    it("gets and sets categoryId", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test Field",
+            type: "text",
+            category: "5",
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.categoryId).toBe("5");
+        formField.categoryId = "3";
+        expect(formField.categoryId).toBe("3");
+    });
+    it("gets and sets choices", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test",
+            type: "dropdown",
+            category: "1",
+            choices: [
+                { text: "Option 1", value: "1" },
+                { text: "Option 2", value: "2" },
+            ],
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.choices).toEqual([
+            { text: "Option 1", value: "1" },
+            { text: "Option 2", value: "2" },
+        ]);
+        formField.choices = [{ text: "New", value: "n" }];
+        expect(formField.choices).toEqual([{ text: "New", value: "n" }]);
+    });
+    it("gets choices with undefined choices returns empty array", () => {
+        const fieldObject = {
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+        };
+        const formField = FormField.fromObject(fieldObject);
+        expect(formField.choices).toEqual([]);
+    });
+    it("gets startWithNewLine default true", () => {
+        const formField = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+        });
+        expect(formField.startWithNewLine).toBe(true);
+    });
+    it("gets startWithNewLine false", () => {
+        const formField = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            startWithNewLine: false,
+        });
+        expect(formField.startWithNewLine).toBe(false);
+    });
+    it("gets requiredForEvaluation default true", () => {
+        const formField = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+        });
+        expect(formField.requiredForEvaluation).toBe(true);
+    });
+    it("gets requiredForEvaluation false", () => {
+        const formField = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "boolean",
+            category: "7",
+            requiredForEvaluation: false,
+        });
+        expect(formField.requiredForEvaluation).toBe(false);
+    });
+    it("parses maxLength, min, max from strings", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            maxLength: "100",
+            min: "10.5",
+            max: "50.5",
+        });
+        expect(field.maxLength).toBe(100);
+        expect(field.min).toBe(10.5);
+        expect(field.max).toBe(50.5);
+    });
+    it("gets maxLength as number", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            maxLength: 18,
+        });
+        expect(field.maxLength).toBe(18);
+    });
+    it("gets undefined for missing optional properties", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+        });
+        expect(field.placeholder).toBeUndefined();
+        expect(field.validators).toBeUndefined();
+        expect(field.maxLength).toBeUndefined();
+        expect(field.min).toBeUndefined();
+        expect(field.max).toBeUndefined();
+    });
+    it("gets placeholder and validators", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            placeholder: "Enter something",
+            validators: [{ type: "numeric", text: "Too high", maxValue: 50 }],
+        });
+        expect(field.placeholder).toBe("Enter something");
+        expect(field.validators).toEqual([
+            { type: "numeric", text: "Too high", maxValue: 50 },
+        ]);
+    });
+    it("gets and sets defaultValue", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            defaultValue: "initial-value",
+        });
+        expect(field.defaultValue).toBe("initial-value");
+        field.defaultValue = "new-value";
+        expect(field.defaultValue).toBe("new-value");
+        expect(field.toJSON().defaultValue).toBe("new-value");
+    });
+    it("handles numeric defaultValue", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            defaultValue: 12345,
+        });
+        expect(field.defaultValue).toBe(12345);
+    });
+});
+describe("FormField toJSON", () => {
+    it("serializes basic field", () => {
+        const formField = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            inputType: "text",
+        });
+        expect(formField).toBeInstanceOf(BasicFormField);
+        expect(formField.toJSON()).toEqual({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            inputType: "text",
+        });
+    });
+    it("serializes file field", () => {
+        const formField = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "file",
+            category: "1",
+            inputType: "text",
+            ihs_column_names: ["col1", "col2"],
+        });
+        expect(formField).toBeInstanceOf(FileFormField);
+        expect(formField.toJSON()).toEqual({
+            name: "test",
+            displayName: "Test",
+            type: "file",
+            category: "1",
+            inputType: "text",
+            ihs_column_names: ["col1", "col2"],
+        });
+    });
+});
+describe("FormField validation", () => {
+    it("throws when name is missing", () => {
+        expect(() => FormField.fromObject({
+            displayName: "Test",
+            type: "text",
+            category: "1",
+        })).toThrow(/name is required/);
+    });
+    it("throws when displayName is missing", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            type: "text",
+            category: "1",
+        })).toThrow(/missing displayName or category/);
+    });
+    it("throws when category is missing", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+        })).toThrow(/missing displayName or category/);
+    });
+    it("throws when both displayName and category are missing", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            type: "text",
+        })).toThrow(/missing displayName or category/);
+    });
+    it("throws when displayName is empty string", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            displayName: "",
+            type: "text",
+            category: "1",
+        })).toThrow(/missing displayName or category/);
+    });
+    it("throws when displayName and category are null", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            displayName: null,
+            type: "text",
+            category: null,
+        })).toThrow(/missing displayName or category/);
+    });
+    it("throws for invalid field type", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "invalid",
+            category: "1",
+        })).toThrow();
+    });
+    it("throws for dropdown without choices", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "dropdown",
+            category: "1",
+        })).toThrow(/type dropdown, but does not have choices/);
+    });
+    it("allows choices on non-dropdown fields", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            choices: [{ text: "testChoice", value: "01" }],
+        })).not.toThrow();
+    });
+    it("allows unknown inputTypes", () => {
+        expect(() => FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            inputType: "invalid",
+            category: "1",
+        })).not.toThrow();
+    });
+});
+describe("FormField runtime - all field types", () => {
+    it("correctly identifies all supported field types", () => {
+        const validTypes = [
+            { input: "text", expected: FieldType.TEXT },
+            { input: "file", expected: FieldType.FILE },
+            { input: "dropdown", expected: FieldType.DROPDOWN },
+            { input: "boolean", expected: FieldType.BOOLEAN },
+            { input: "checkbox", expected: FieldType.CHECKBOX },
+            { input: "radiogroup", expected: FieldType.RADIOGROUP },
+            { input: "slider", expected: FieldType.SLIDER },
+            { input: "html", expected: FieldType.HTML },
+            { input: "tagbox", expected: FieldType.TAGBOX },
+        ];
+        for (const { input, expected } of validTypes) {
+            const fieldData = {
+                name: "test",
+                displayName: "Test",
+                type: input,
+                category: "cat1",
+            };
+            if (input === "dropdown") {
+                fieldData.choices = [{ text: "Yes", value: "yes" }];
+            }
+            const field = FormField.fromObject(fieldData);
+            expect(field.type).toBe(expected);
+        }
+    });
+    it("throws error for invalid or unknown field types", () => {
+        const invalidInputs = ["invalid", "", "something_else", null, undefined];
+        for (const input of invalidInputs) {
+            expect(() => {
+                FormField.fromObject({
+                    name: "test",
+                    displayName: "Test",
+                    type: input,
+                    category: "cat1",
+                });
+            }).toThrow();
+        }
+    });
+});
+describe("FileFormField", () => {
+    it("returns empty when requiredForEvaluation is false", () => {
+        const field = FormField.fromObject({
+            name: "file_field",
+            displayName: "File Field",
+            type: "file",
+            category: "cat1",
+            requiredForEvaluation: false,
+            ihs_column_names: ["col1", "col2"],
+        });
+        expect(field.getFieldNames()).toEqual([]);
+    });
+    it("returns ihs_column_names when requiredForEvaluation is true", () => {
+        const field = FormField.fromObject({
+            name: "file_field",
+            displayName: "File Field",
+            type: "file",
+            category: "cat1",
+            ihs_column_names: ["col1", "col2"],
+        });
+        expect(field.getFieldNames()).toEqual(["col1", "col2"]);
+    });
+});
+describe("BasicFormField", () => {
+    it("returns empty when requiredForEvaluation is false", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+            requiredForEvaluation: false,
+        });
+        expect(field.getFieldNames()).toEqual([]);
+    });
+    it("returns field name when requiredForEvaluation is true", () => {
+        const field = FormField.fromObject({
+            name: "test",
+            displayName: "Test",
+            type: "text",
+            category: "1",
+        });
+        expect(field.getFieldNames()).toEqual(["test"]);
+    });
+});