@finsys/core 1.1.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@finsys/core",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Convert unified form configurations into Zod schemas, React Hook Form defaults, and SurveyJS JSON",
   "repository": {
     "type": "git",
@@ -10,18 +10,19 @@
   "bugs": {
     "url": "https://github.com/ExtraGalaxies/finsys-core/issues"
   },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "type": "module",
   "exports": {
     ".": {
-      "import": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     },
     "./schema": {
-      "import": "./dist/schema/unified-form.schema.json"
+      "import": "./dist/schema/unified-form.schema.json",
+      "require": "./dist/schema/unified-form.schema.json"
     }
   },
   "files": [
@@ -30,8 +31,8 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc && cp src/schema/unified-form.schema.json dist/schema/unified-form.schema.json && rm -rf dist/data && cp -r src/data dist/data",
-    "dev": "tsc --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "test": "vitest run",
     "lint": "tsc --noEmit",
     "prepublishOnly": "npm run build"
@@ -54,6 +55,7 @@
     "@types/node": "^25.0.10",
     "@types/semver": "^7.5.0",
     "survey-core": "^2.5.6",
+    "tsup": "^8.5.1",
     "typescript": "^5.4.0",
     "vitest": "^4.0.18"
   },

package/dist/catalogs.d.ts

@@ -1,13 +0,0 @@
-import type { FieldData, Category } from "./survey-generator.js";
-import type { FormFieldTypeDefinitions } from "./form-field.js";
-import type { FormValidatorDefinitions } from "./form-field-validator.js";
-export declare const BASE_FIELD_SPECS: {
-    schemaVersion: string;
-    categories: Category[];
-    fields: FieldData[];
-};
-export declare const FIELD_TYPE_DEFINITIONS: FormFieldTypeDefinitions;
-export declare const DEFAULT_VALIDATOR_DEFINITIONS: FormValidatorDefinitions;
-export declare function getBaseFieldSpecs(): FieldData[];
-export declare function getBaseCategories(): Category[];
-export declare function getBaseFieldNames(): string[];

package/dist/catalogs.js

@@ -1,35 +0,0 @@
-import FormField from "./form-field.js";
-import baseSpecsData from "./data/form-field-base-specs.json" with { type: "json" };
-import typeDefsData from "./data/form-field-types.json" with { type: "json" };
-import validatorDefsData from "./data/form-field-validators.json" with { type: "json" };
-export const BASE_FIELD_SPECS = baseSpecsData;
-export const FIELD_TYPE_DEFINITIONS = typeDefsData;
-export const DEFAULT_VALIDATOR_DEFINITIONS = {
-    version: validatorDefsData.version,
-    options: validatorDefsData.options,
-};
-export function getBaseFieldSpecs() {
-    return BASE_FIELD_SPECS.fields;
-}
-export function getBaseCategories() {
-    return BASE_FIELD_SPECS.categories;
-}
-let cachedFieldNames = null;
-export function getBaseFieldNames() {
-    if (cachedFieldNames) {
-        return cachedFieldNames;
-    }
-    const fields = BASE_FIELD_SPECS.fields;
-    const names = [];
-    for (const field of fields) {
-        try {
-            const formField = FormField.fromObject(field);
-            names.push(...formField.getFieldNames());
-        }
-        catch {
-            // Skip fields that fail to parse
-        }
-    }
-    cachedFieldNames = [...new Set(names)];
-    return cachedFieldNames;
-}

package/dist/catalogs.test.d.ts

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

package/dist/catalogs.test.js

@@ -1,207 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { generateRHFSchema } from "./rhf-generator.js";
-import { BASE_FIELD_SPECS, FIELD_TYPE_DEFINITIONS, DEFAULT_VALIDATOR_DEFINITIONS, getBaseFieldSpecs, getBaseCategories, getBaseFieldNames, } from "./catalogs.js";
-describe("BASE_FIELD_SPECS", () => {
-    it("has schemaVersion, categories, and fields", () => {
-        expect(BASE_FIELD_SPECS.schemaVersion).toBeDefined();
-        expect(Array.isArray(BASE_FIELD_SPECS.categories)).toBe(true);
-        expect(Array.isArray(BASE_FIELD_SPECS.fields)).toBe(true);
-        expect(BASE_FIELD_SPECS.categories.length).toBeGreaterThan(0);
-        expect(BASE_FIELD_SPECS.fields.length).toBeGreaterThan(0);
-    });
-});
-describe("FIELD_TYPE_DEFINITIONS", () => {
-    it("has version, types, and input_types", () => {
-        expect(FIELD_TYPE_DEFINITIONS.version).toBeDefined();
-        expect(Array.isArray(FIELD_TYPE_DEFINITIONS.types)).toBe(true);
-        expect(Array.isArray(FIELD_TYPE_DEFINITIONS.input_types)).toBe(true);
-        expect(FIELD_TYPE_DEFINITIONS.types.length).toBeGreaterThan(0);
-        expect(FIELD_TYPE_DEFINITIONS.input_types.length).toBeGreaterThan(0);
-    });
-});
-describe("DEFAULT_VALIDATOR_DEFINITIONS", () => {
-    it("has version and options", () => {
-        expect(DEFAULT_VALIDATOR_DEFINITIONS.version).toBeDefined();
-        expect(Array.isArray(DEFAULT_VALIDATOR_DEFINITIONS.options)).toBe(true);
-        expect(DEFAULT_VALIDATOR_DEFINITIONS.options.length).toBeGreaterThan(0);
-    });
-});
-describe("getBaseFieldSpecs", () => {
-    it("returns field array", () => {
-        const fields = getBaseFieldSpecs();
-        expect(Array.isArray(fields)).toBe(true);
-        expect(fields.length).toBeGreaterThan(0);
-        expect(fields[0].name).toBeDefined();
-        expect(fields[0].type).toBeDefined();
-    });
-});
-describe("getBaseCategories", () => {
-    it("returns category array", () => {
-        const categories = getBaseCategories();
-        expect(Array.isArray(categories)).toBe(true);
-        expect(categories.length).toBeGreaterThan(0);
-        expect(categories[0].id).toBeDefined();
-        expect(categories[0].name).toBeDefined();
-    });
-});
-describe("getBaseFieldNames", () => {
-    it("returns unique field names", () => {
-        const names = getBaseFieldNames();
-        expect(Array.isArray(names)).toBe(true);
-        expect(names.length).toBeGreaterThan(0);
-        // Should be unique
-        expect(new Set(names).size).toBe(names.length);
-    });
-});
-describe("Base Specs Zod Validation", () => {
-    it("all field definitions should be valid for RHF schema generation", () => {
-        const fields = BASE_FIELD_SPECS.fields;
-        const categories = BASE_FIELD_SPECS.categories;
-        const failedFields = [];
-        fields.forEach((field) => {
-            try {
-                const config = {
-                    schemaVersion: "v2.0.0",
-                    displayName: "Test",
-                    categories: categories,
-                    fields: {
-                        [field.name]: field,
-                    },
-                    pages: [
-                        {
-                            id: "test-page",
-                            fields: [field.name],
-                        },
-                    ],
-                };
-                const { zodSchema, defaultValues } = generateRHFSchema(config);
-                const result = zodSchema.safeParse(defaultValues);
-                if (!result.success) {
-                    const hasRequirementError = result.error.issues.some((i) => i.message === "This field is required" || i.code === "too_small");
-                    const isRequired = field.isRequired !== false && field.required !== false;
-                    if (!(isRequired && hasRequirementError && !field.defaultValue)) {
-                        failedFields.push({
-                            name: field.name,
-                            error: `Validation failed: ${JSON.stringify(result.error.issues)}`,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                failedFields.push({
-                    name: field.name,
-                    error: `Exception: ${error.message}`,
-                });
-            }
-        });
-        if (failedFields.length > 0) {
-            const errorMsg = failedFields.map((f) => `[${f.name}]: ${f.error}`).join("\n");
-            expect.unreachable(`Found ${failedFields.length} invalid field definitions:\n${errorMsg.substring(0, 2000)}`);
-        }
-    });
-});
-describe("Field Types Zod Validation", () => {
-    it("all supported type combinations should be valid for RHF schema generation", () => {
-        const types = FIELD_TYPE_DEFINITIONS.types;
-        const inputTypes = FIELD_TYPE_DEFINITIONS.input_types;
-        const failedCombinations = [];
-        for (const typeObj of types) {
-            const baseType = typeObj.name;
-            const targetInputTypes = baseType === "text" ? inputTypes : [{ name: undefined }];
-            for (const inputTypeObj of targetInputTypes) {
-                const inputType = inputTypeObj.name;
-                try {
-                    const field = {
-                        name: "testField",
-                        displayName: "Test Field",
-                        category: "1",
-                        type: baseType,
-                    };
-                    if (inputType)
-                        field.inputType = inputType;
-                    const config = {
-                        schemaVersion: "v2.0.0",
-                        displayName: "Test",
-                        categories: [{ id: "1", name: "Test" }],
-                        fields: { [field.name]: field },
-                        pages: [{ id: "test-page", fields: [field.name] }],
-                    };
-                    const { zodSchema, defaultValues } = generateRHFSchema(config);
-                    const result = zodSchema.safeParse(defaultValues);
-                    if (!result.success) {
-                        const errors = result.error.issues.filter((i) => i.message !== "This field is required" && i.code !== "too_small");
-                        if (errors.length > 0) {
-                            failedCombinations.push({
-                                type: baseType,
-                                inputType,
-                                error: `Validation failed: ${JSON.stringify(errors)}`,
-                            });
-                        }
-                    }
-                }
-                catch (error) {
-                    failedCombinations.push({
-                        type: baseType,
-                        inputType,
-                        error: `Exception: ${error.message}`,
-                    });
-                }
-            }
-        }
-        if (failedCombinations.length > 0) {
-            const errorMsg = failedCombinations
-                .map((c) => `[${c.type}${c.inputType ? "/" + c.inputType : ""}]: ${c.error}`)
-                .join("\n");
-            expect.unreachable(`Found ${failedCombinations.length} invalid type combinations:\n${errorMsg}`);
-        }
-    });
-});
-describe("Field Validators Zod Validation", () => {
-    it("all shared validator definitions should be valid for RHF schema generation", () => {
-        const options = DEFAULT_VALIDATOR_DEFINITIONS.options;
-        const failedValidators = [];
-        options.forEach((option) => {
-            try {
-                const field = {
-                    name: "testField",
-                    displayName: "Test Field",
-                    category: "1",
-                    type: "text",
-                    validators: option.validators || [],
-                };
-                if (option.validators?.some((v) => v.type === "numeric")) {
-                    field.type = "number";
-                    field.inputType = "number";
-                }
-                const config = {
-                    schemaVersion: "v2.0.0",
-                    displayName: "Test",
-                    categories: [{ id: "1", name: "Test" }],
-                    fields: { [field.name]: field },
-                    pages: [{ id: "test-page", fields: [field.name] }],
-                };
-                const { zodSchema, defaultValues } = generateRHFSchema(config);
-                const result = zodSchema.safeParse(defaultValues);
-                if (!result.success) {
-                    const errors = result.error.issues.filter((i) => i.message !== "This field is required");
-                    if (errors.length > 0) {
-                        failedValidators.push({
-                            name: option.displayName,
-                            error: `Validation failed: ${JSON.stringify(errors)}`,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                failedValidators.push({
-                    name: option.displayName,
-                    error: `Exception: ${error.message}`,
-                });
-            }
-        });
-        if (failedValidators.length > 0) {
-            const errorMsg = failedValidators.map((f) => `[${f.name}]: ${f.error}`).join("\n");
-            expect.unreachable(`Found ${failedValidators.length} invalid validator definitions:\n${errorMsg.substring(0, 2000)}`);
-        }
-    });
-});

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

@@ -1,12 +0,0 @@
-export declare class FormFieldCategory {
-    private _id;
-    private _name;
-    constructor(id: string | number, name: string);
-    get id(): string;
-    get name(): string;
-    set name(value: string);
-    toJSON(): {
-        id: string;
-        name: string;
-    };
-}

package/dist/form-field-category.js

@@ -1,21 +0,0 @@
-export class FormFieldCategory {
-    constructor(id, name) {
-        this._id = String(id);
-        this._name = name;
-    }
-    get id() {
-        return this._id;
-    }
-    get name() {
-        return this._name;
-    }
-    set name(value) {
-        this._name = value;
-    }
-    toJSON() {
-        return {
-            id: this._id,
-            name: this._name,
-        };
-    }
-}

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

@@ -1,18 +0,0 @@
-import type { Validator } from "./survey-generator.js";
-import type { EditorValidator } from "./form-field.js";
-export interface FormValidatorDefinitions {
-    options: EditorValidator[];
-    version: number;
-}
-export declare class FormFieldValidator implements EditorValidator {
-    id: number;
-    displayName: string;
-    class: string;
-    description: string;
-    isRequired: boolean;
-    validators: Validator[];
-    constructor(validatorData: EditorValidator);
-    validate(value: any): boolean;
-    private validateNumeric;
-    private validateText;
-}

package/dist/form-field-validator.js

@@ -1,41 +0,0 @@
-export class FormFieldValidator {
-    constructor(validatorData) {
-        this.id = validatorData.id;
-        this.displayName = validatorData.displayName;
-        this.class = validatorData.class;
-        this.description = validatorData.description;
-        this.isRequired = validatorData.isRequired;
-        this.validators = validatorData.validators;
-    }
-    validate(value) {
-        for (const validator of this.validators) {
-            switch (validator.type) {
-                case 'numeric':
-                    if (!this.validateNumeric(value, validator.minValue, validator.maxValue)) {
-                        return false;
-                    }
-                    break;
-                case 'text':
-                    if (!this.validateText(value, validator.minLength, validator.maxLength)) {
-                        return false;
-                    }
-                    break;
-            }
-        }
-        return true;
-    }
-    validateNumeric(value, min, max) {
-        if (min !== undefined && value < min)
-            return false;
-        if (max !== undefined && value > max)
-            return false;
-        return true;
-    }
-    validateText(value, minLength, maxLength) {
-        if (minLength !== undefined && value.length < minLength)
-            return false;
-        if (maxLength !== undefined && value.length > maxLength)
-            return false;
-        return true;
-    }
-}

package/dist/form-field.d.ts

@@ -1,81 +0,0 @@
-import type { FieldData, Choice, Validator } from "./survey-generator.js";
-export declare enum FieldType {
-    FILE = "file",
-    TEXT = "text",
-    DROPDOWN = "dropdown",
-    BOOLEAN = "boolean",
-    CHECKBOX = "checkbox",
-    RADIOGROUP = "radiogroup",
-    SLIDER = "slider",
-    HTML = "html",
-    TAGBOX = "tagbox",
-    NUMBER = "number",
-    EMAIL = "email",
-    COMMENT = "comment",
-    RANGE = "range",
-    UNKNOWN = "unknown"
-}
-export interface FormFieldType {
-    name: string;
-    displayName: string;
-}
-export interface FormFieldInputType {
-    name: string;
-    displayName: string;
-}
-export interface FormFieldTypeDefinitions {
-    version: number;
-    types: FormFieldType[];
-    input_types: FormFieldInputType[];
-}
-export interface DropdownOption {
-    id: number;
-    name: string;
-    displayName: string;
-    choices: Choice[];
-}
-export interface EditorValidator {
-    id: number;
-    displayName: string;
-    class: string;
-    description: string;
-    isRequired: boolean;
-    validators: Validator[];
-}
-export default abstract class FormField {
-    fieldObject: FieldData;
-    constructor(name: string, displayName: string, type: string, category: string);
-    static fromObject(fieldObject: FieldData): FormField;
-    abstract getFieldNames(): string[];
-    protected cleanObject(obj: any): any;
-    toJSON(): any;
-    get displayName(): string;
-    set displayName(newDisplayName: string);
-    get name(): string;
-    get type(): FieldType;
-    get inputType(): string;
-    get categoryId(): string;
-    set categoryId(categoryId: string);
-    get defaultValue(): any;
-    set defaultValue(value: any);
-    get placeholder(): string | undefined;
-    get validators(): Validator[] | undefined;
-    get choices(): Choice[];
-    set choices(choices: Choice[]);
-    get visible(): boolean;
-    get visibleIf(): string | undefined;
-    get isRequired(): boolean;
-    get startWithNewLine(): boolean;
-    get requiredForEvaluation(): boolean;
-    get maxLength(): number | undefined;
-    get min(): number | undefined;
-    get max(): number | undefined;
-}
-export declare class BasicFormField extends FormField {
-    constructor(name: string, displayName: string, type: string, category: string);
-    getFieldNames(): string[];
-}
-export declare class FileFormField extends FormField {
-    constructor(name: string, displayName: string, type: string, category: string, ihs_column_names: string[]);
-    getFieldNames(): string[];
-}

package/dist/form-field.js

@@ -1,197 +0,0 @@
-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 || [];
-    }
-}