ngx-t-forms-types 0.0.1

package/dist/schemas/MatOptionsSchema.d.ts

@@ -0,0 +1,8 @@
+import Joi from 'joi';
+declare const FormInputBasicOptionSchema: Joi.ObjectSchema<any>;
+declare const MinInputMapInputSchema: Joi.ObjectSchema<any>;
+declare const minimumInputRequiredSchema: Joi.ObjectSchema<any>;
+declare const APIDataFetchingConfigurationSchema: Joi.ObjectSchema<any>;
+declare const MongoDbPipeLineConfigSchema: Joi.ObjectSchema<any>;
+declare const MatDataOptionsSchema: Joi.ObjectSchema<any>;
+export { MatDataOptionsSchema, APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema, FormInputBasicOptionSchema, MinInputMapInputSchema, minimumInputRequiredSchema };

package/dist/schemas/MatOptionsSchema.js

@@ -0,0 +1,54 @@
+import Joi from 'joi';
+import { ElementTypes, InputDataTypes, MinInputTypes } from '../interfaces/formInput';
+import { JsDataTypes } from '../interfaces/formInput/MinimumInputRequiredInterface';
+const DynamicObjectSchema = Joi.object().pattern(Joi.alternatives().try(Joi.string(), Joi.number()), Joi.alternatives().try(Joi.number(), Joi.string(), Joi.boolean(), Joi.object()));
+const FormInputBasicOptionSchema = Joi.object({
+    label: Joi.string().optional(),
+    value: Joi.string().required()
+});
+const MinInputMapInputSchema = Joi.object({
+    formControlName: Joi.string().required(),
+    dataType: Joi.string().valid(...Object.values(InputDataTypes)).required(),
+    element: Joi.string().valid(...Object.values(ElementTypes)).required()
+});
+const minimumInputRequiredSchema = Joi.object({
+    name: Joi.string().required(),
+    type: Joi.string().valid(...Object.values(MinInputTypes), ...Object.values(JsDataTypes)).required(),
+    value: Joi.string().optional(),
+    mapTo: Joi.alternatives().try(MinInputMapInputSchema, Joi.array().items(MinInputMapInputSchema)).optional(),
+    defaultValue: Joi.string().optional(),
+    dataFor: Joi.string().optional(),
+    activeChangeId: Joi.string().optional(),
+    primaryKey: Joi.boolean().optional()
+});
+const APIDataFetchingConfigurationSchema = Joi.object({
+    _id: Joi.string().required(),
+    name: Joi.string().required(),
+    httpEndPoint: Joi.string().required(),
+    inputSourceId: Joi.string().optional(),
+    httpMethod: Joi.string().valid('GET', 'POST', 'PUT', 'DELETE').required(),
+    postFormData: Joi.boolean().required(),
+    backEndConfig: Joi.object({
+        minimumInputRequired: Joi.array().items(minimumInputRequiredSchema).required()
+    }).optional(),
+    valueAccessRules: Joi.alternatives().try(FormInputBasicOptionSchema, Joi.array().items(Joi.object())).optional(),
+    source: Joi.string().valid('local', 'api', 'mongoPipeline', 'customOptions').required(),
+    projectFormData: Joi.string().optional()
+});
+const MongoDbPipeLineConfigSchema = Joi.object({
+    workflowId: Joi.string().required(),
+    pipeline: Joi.array().items(Joi.any()).required(),
+    valueAccessRules: Joi.alternatives().try(FormInputBasicOptionSchema, Joi.array().items(Joi.object())).required(),
+    source: Joi.string().valid('local', 'api', 'mongoPipeline', 'customOptions').required(),
+    responseBody: Joi.any().required()
+});
+const MatDataOptionsSchema = Joi.object({
+    optionType: Joi.string().valid('user').optional(),
+    options: Joi.array().items(Joi.alternatives().try(FormInputBasicOptionSchema, DynamicObjectSchema)).optional(),
+    fetchFor: Joi.string().valid('valueForOptions').optional(),
+    fetch: Joi.object({
+        value: Joi.alternatives().try(APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema, Joi.object()).optional(),
+        options: Joi.alternatives().try(APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema, Joi.object()).optional()
+    }).required()
+});
+export { MatDataOptionsSchema, APIDataFetchingConfigurationSchema, MongoDbPipeLineConfigSchema, FormInputBasicOptionSchema, MinInputMapInputSchema, minimumInputRequiredSchema };

package/dist/schemas/MscoaConfigSchema.d.ts

@@ -0,0 +1,8 @@
+import Joi from 'joi';
+export declare const IncludedSegmentConfigSchema: Joi.ObjectSchema<any>;
+export declare const MscoaInnerInputSchema: Joi.ObjectSchema<any>;
+export declare const MscoaInputConfigSchema: Joi.ObjectSchema<any>;
+export declare function validateMscoaInputConfig(value: any): {
+    error: Joi.ValidationError | undefined;
+    value: any;
+};

package/dist/schemas/MscoaConfigSchema.js

@@ -0,0 +1,22 @@
+import Joi from 'joi';
+export const IncludedSegmentConfigSchema = Joi.object({
+    segment: Joi.string().required(),
+    label: Joi.string().required(),
+    readOnly: Joi.boolean().required(),
+    singleSelect: Joi.boolean().required()
+});
+export const MscoaInnerInputSchema = Joi.object({
+    segment: Joi.string().required(),
+    id: Joi.string().required(),
+    label: Joi.string().required(),
+    formControlName: Joi.string().required(),
+});
+export const MscoaInputConfigSchema = Joi.object({
+    inputs: Joi.array().items(MscoaInnerInputSchema).required(),
+    segments: Joi.array().items(IncludedSegmentConfigSchema).min(1).required(),
+    showAllSegments: Joi.boolean().required()
+});
+export function validateMscoaInputConfig(value) {
+    const { error, value: validatedValue } = MscoaInputConfigSchema.validate(value);
+    return { error, value: validatedValue };
+}

package/dist/schemas/customValidationSchema.d.ts

@@ -0,0 +1,2 @@
+import * as Joi from 'joi';
+export declare const formControlCustomValidatorSchema: Joi.ObjectSchema<any>;

package/dist/schemas/customValidationSchema.js

@@ -0,0 +1,8 @@
+import * as Joi from 'joi';
+export const formControlCustomValidatorSchema = Joi.object({
+    id: Joi.string().required(),
+    message: Joi.string().required(),
+    expression: Joi.string().required(),
+    canOverride: Joi.boolean().required(),
+    inputsObservedForChanges: Joi.array().items(Joi.string()).required()
+});

package/dist/schemas/index.d.ts

@@ -0,0 +1,4 @@
+import { validateCalculatedFieldRules } from "./CalculatedFieldRulesSchema";
+import { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired } from "./FormInputSchema";
+import { validateApiDataFetchingConfiguration, validateForm, validateFormSlide } from "./FormSchema";
+export { formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration };

package/dist/schemas/index.js

@@ -0,0 +1,4 @@
+import { validateCalculatedFieldRules } from "./CalculatedFieldRulesSchema";
+import { formColumnInputsSchema, validateFormColumnInputs, validateFormColumnInputsWithRequired } from "./FormInputSchema";
+import { validateApiDataFetchingConfiguration, validateForm, validateFormSlide } from "./FormSchema";
+export { formColumnInputsSchema, validateCalculatedFieldRules, validateFormColumnInputs, validateFormSlide, validateFormColumnInputsWithRequired, validateForm, validateApiDataFetchingConfiguration };

package/dist/schemas/tests/FormInputValidator.spec.d.ts

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

package/dist/schemas/tests/FormInputValidator.spec.js

@@ -0,0 +1,68 @@
+import { TestBed } from '@angular/core/testing';
+import { AllFormInputPrimaryKeys, } from '../../interfaces/FormBuilder';
+import { ElementTypes, InputDataTypes, InputPipeTypes, InputTypes } from '../../interfaces/formInput';
+import { formColumnInputsSchema } from '../FormInputSchema';
+//ng test ngx-t-forms --include='projects/ngx-t-forms/src/lib/schemas/tests/FormInputValidator.spec.ts'
+describe('FormInputValidator', () => {
+    beforeEach(() => {
+        TestBed.configureTestingModule({});
+    });
+    it('should validate a valid form input configuration', () => {
+        const validInput = {
+            [AllFormInputPrimaryKeys.Element]: ElementTypes.Input,
+            [AllFormInputPrimaryKeys.ColSize]: 6,
+            [AllFormInputPrimaryKeys.Label]: 'Test Label',
+            [AllFormInputPrimaryKeys.FormControlName]: 'testControl',
+            [AllFormInputPrimaryKeys.Appearance]: 'outline',
+            [AllFormInputPrimaryKeys.Required]: true,
+            [AllFormInputPrimaryKeys.DataType]: InputDataTypes.String,
+            [AllFormInputPrimaryKeys.Validators]: ['required']
+        };
+        const result = formColumnInputsSchema.validate(validInput);
+        expect(result.error).toBeUndefined();
+    });
+    it('should fail validation when required fields are missing', () => {
+        const invalidInput = {
+            [AllFormInputPrimaryKeys.Label]: 'Test Label',
+            [AllFormInputPrimaryKeys.FormControlName]: 'testControl'
+        };
+        const result = formColumnInputsSchema.validate(invalidInput);
+        expect(result.error).toBeDefined();
+    });
+    it('should validate optional fields when provided correctly', () => {
+        const inputWithOptionals = {
+            [AllFormInputPrimaryKeys.Element]: ElementTypes.Input,
+            [AllFormInputPrimaryKeys.ColSize]: 6,
+            [AllFormInputPrimaryKeys.Label]: 'Test Label',
+            [AllFormInputPrimaryKeys.FormControlName]: 'testControl',
+            [AllFormInputPrimaryKeys.Appearance]: 'outline',
+            [AllFormInputPrimaryKeys.Required]: true,
+            [AllFormInputPrimaryKeys.DataType]: InputDataTypes.String,
+            [AllFormInputPrimaryKeys.Validators]: ['required'],
+            [AllFormInputPrimaryKeys.Type]: InputTypes.Text,
+            [AllFormInputPrimaryKeys.Min]: 0,
+            [AllFormInputPrimaryKeys.Max]: 100,
+            [AllFormInputPrimaryKeys.Pipe]: {
+                pipeType: InputPipeTypes.Currency,
+                param: 'USD'
+            }
+        };
+        const result = formColumnInputsSchema.validate(inputWithOptionals);
+        console.warn(result, "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy");
+        expect(result.error).toBeUndefined();
+    });
+    it('should fail validation for invalid enum values', () => {
+        const invalidEnumInput = {
+            [AllFormInputPrimaryKeys.Element]: 'InvalidElement',
+            [AllFormInputPrimaryKeys.ColSize]: 6,
+            [AllFormInputPrimaryKeys.Label]: 'Test Label',
+            [AllFormInputPrimaryKeys.FormControlName]: 'testControl',
+            [AllFormInputPrimaryKeys.Appearance]: 'outline',
+            [AllFormInputPrimaryKeys.Required]: true,
+            [AllFormInputPrimaryKeys.DataType]: InputDataTypes.String,
+            [AllFormInputPrimaryKeys.Validators]: ['required']
+        };
+        const result = formColumnInputsSchema.validate(invalidEnumInput);
+        expect(result.error).toBeDefined();
+    });
+});

package/dist/schemas/tests/MOCK_DATA.d.ts

@@ -0,0 +1,49 @@
+export declare const validCalculatedFieldRules: {
+    formula: string;
+    variables: {
+        formControlName: string;
+        label: string;
+        variable: string;
+        inputId: string;
+        id: string;
+    }[];
+};
+export declare const invalidCalculatedFieldRules: {
+    getFormulaFromAFormInput: string;
+    formula: string;
+    variables: {
+        formControlName: string;
+        label: string;
+        variable: string;
+        inputId: string;
+        id: string;
+    }[];
+};
+export declare const validMscoaConfig: {
+    inputs: {
+        segment: string;
+        id: string;
+        label: string;
+        formControlName: string;
+    }[];
+    segments: {
+        segment: string;
+        label: string;
+        readOnly: boolean;
+        singleSelect: boolean;
+    }[];
+    showAllSegments: boolean;
+};
+export declare const invalidMscoaConfig: {
+    inputs: {
+        segment: string;
+        id: string;
+    }[];
+    segments: {
+        segment: string;
+        label: string;
+        readOnly: boolean;
+        singleSelect: boolean;
+    }[];
+    showAllSegments: boolean;
+};

package/dist/schemas/tests/MOCK_DATA.js

@@ -0,0 +1,59 @@
+export const validCalculatedFieldRules = {
+    formula: 'a + b',
+    variables: [
+        {
+            formControlName: 'control1',
+            label: 'label1',
+            variable: 'a',
+            inputId: 'inputId1',
+            id: 'id1',
+        },
+        {
+            formControlName: 'control2',
+            label: 'label2',
+            inputId: 'inputId2',
+            variable: 'b',
+            id: 'id2',
+        },
+    ],
+};
+export const invalidCalculatedFieldRules = {
+    ...validCalculatedFieldRules,
+    getFormulaFromAFormInput: 'invalid_boolean',
+};
+export const validMscoaConfig = {
+    inputs: [
+        {
+            segment: 'segment1',
+            id: 'id1',
+            label: 'label1',
+            formControlName: 'control1',
+        },
+    ],
+    segments: [
+        {
+            segment: 'segment1',
+            label: 'label1',
+            readOnly: true,
+            singleSelect: false,
+        },
+    ],
+    showAllSegments: true,
+};
+export const invalidMscoaConfig = {
+    inputs: [
+        {
+            segment: 'segment1',
+            id: 'id1',
+        },
+    ],
+    segments: [
+        {
+            segment: 'segment1',
+            label: 'label1',
+            readOnly: true,
+            singleSelect: false,
+        },
+    ],
+    showAllSegments: true,
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "ngx-t-forms-types",
+  "version": "0.0.1",
+  "description": "Typings and interfaces for the ngx-t-forms library for dynamic forms.",
+  "keywords": [
+    "typings",
+    "typescript"
+  ],
+  "homepage": "https://github.com/mashegoTerrence/ngx-t-forms-typings#readme",
+  "bugs": {
+    "url": "https://github.com/mashegoTerrence/ngx-t-forms-typings/issues"
+  },
+  "publishConfig":{
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mashegoTerrence/ngx-t-forms-typings.git"
+  },
+  "license": "ISC",
+  "author": "mashegoterrence@gmail.com",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "karma start",
+    "clean": "rimraf dist",
+    "build": "npm run clean && tsc",
+    "prepublishOnly": "npm run build",
+    "dev": "npm run build --watch"
+  },
+  "devDependencies": {
+    "@angular/cdk": "^19.2.2",
+    "@angular/common": "^19.2.1",
+    "@angular/core": "^19.2.1",
+    "@angular/material": "^19.2.2",
+    "@angular/router": "^19.2.1",
+    "@types/jasmine": "^5.1.7",
+    "@types/joi": "^17.2.2",
+    "@types/node": "^22.13.9",
+    "jasmine-core": "^5.6.0",
+    "karma": "^6.4.4",
+    "karma-chrome-launcher": "^3.2.0",
+    "karma-jasmine": "^5.1.0",
+    "karma-webpack": "^5.0.1",
+    "mongoose": "^8.12.1",
+    "rimraf": "^6.0.1",
+    "rxjs": "^7.8.2",
+    "signature_pad": "^5.0.4",
+    "ts-loader": "^9.5.2",
+    "typescript": "^5.8.2",
+    "webpack": "^5.98.0",
+    "webpack-dev-server": "^5.2.0"
+  },
+  "dependencies": {
+   
+  }
+}