@bolttech/form-engine-core 0.0.1-beta.1

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@bolttech/form-engine-core",
+  "version": "0.0.1-beta.1",
+  "module": "./index.esm.js",
+  "type": "module",
+  "main": "./index.esm.js",
+  "dependencies": {
+    "@gaignoux/currency": "1.1.0",
+    "credit-card-type": "10.0.0",
+    "lodash": "4.17.21",
+    "rxjs": "7.8.1"
+  },
+  "peerDependencies": {}
+}

package/src/formatters/creditCard.d.ts

@@ -0,0 +1,23 @@
+import { TFormatters } from '../types/schema';
+/**
+ * Formats a credit card number by adding gaps based on the card type.
+ *
+ * @param {unknown} value - The input value to be formatted, expected to be a string representing a credit card number.
+ * @param {TFormatters} formatters - An object containing formatting options.
+ * @param {boolean} formatters.gapsCreditCard - A flag indicating whether to apply credit card gap formatting.
+ * @returns {unknown} - The formatted credit card number with appropriate gaps, or the original value if formatting is not applied.
+ *
+ * @example
+ * ```typescript
+ * const formatters = { gapsCreditCard: true };
+ * const result = gapsCreditCard('4111111111111111', formatters);
+ * console.log(result); // "4111 1111 1111 1111" (formatted based on card type, e.g., Visa)
+ * ```
+ * @example
+ * ```typescript
+ * const formatters = { gapsCreditCard: false };
+ * const result = gapsCreditCard('4111111111111111', formatters);
+ * console.log(result); // "4111111111111111" (no formatting applied)
+ * ```
+ */
+export declare const gapsCreditCard: (value: unknown, formatters: TFormatters) => unknown;

package/src/formatters/custom.d.ts

@@ -0,0 +1,29 @@
+import { TFormatters } from '../types/schema';
+/**
+ * Applies a custom callback function to format a value.
+ *
+ * @param {unknown} value - The input value to be formatted.
+ * @param {TFormatters} formatters - An object containing formatting options.
+ * @param {(value: unknown) => unknown} formatters.callback - A custom callback function to apply to the value.
+ * @returns {unknown} - The value after applying the custom callback function, or the original value if no callback is provided.
+ *
+ * @example
+ * ```typescript
+ * const formatters = { callback: (val) => `Formatted: ${val}` };
+ * const result = callback('example', formatters);
+ * console.log(result); // "Formatted: example"
+ * ```
+ * @example
+ * ```typescript
+ * const formatters = { callback: (val) => val.toString().toUpperCase() };
+ * const result = callback('example', formatters);
+ * console.log(result); // "EXAMPLE"
+ * ```
+ * @example
+ * ```typescript
+ * const formatters = { callback: null };
+ * const result = callback('example', formatters);
+ * console.log(result); // "example" (no formatting applied)
+ * ```
+ */
+export declare const callback: (value: unknown, formatters: TFormatters) => unknown;

package/src/formatters/handler.d.ts

@@ -0,0 +1,2 @@
+import { TFormatters } from '../types/schema';
+export declare const formatters: Record<keyof TFormatters, (value: unknown, formatters?: TFormatters) => unknown>;

package/src/formatters/regex.d.ts

@@ -0,0 +1,47 @@
+import { TFormatters } from '../types/schema';
+/**
+ * Removes all non-numeric characters from a string.
+ *
+ * @param value - The value to be processed.
+ * @returns The processed value with only numbers.
+ *
+ * @example
+ * ```typescript
+ * import { onlyNumbers } from './path/to/formatterFunctions';
+ *
+ * const processedValue = onlyNumbers('abc123def456');
+ * console.log(processedValue); // Output: '123456'
+ * ```
+ */
+export declare const onlyNumbers: (value: unknown) => string;
+/**
+ * Removes all non-letter characters from a string.
+ *
+ * @param value - The value to be processed.
+ * @returns The processed value with only letters.
+ *
+ * @example
+ * ```typescript
+ * import { onlyLetters } from './path/to/formatterFunctions';
+ *
+ * const processedValue = onlyLetters('abc123def456');
+ * console.log(processedValue); // Output: 'abcdef'
+ * ```
+ */
+export declare const onlyLetters: (value: unknown) => string;
+/**
+ * Applies a regular expression pattern to remove matching substrings from a string.
+ *
+ * @param value - The value to be processed.
+ * @param formatters - An object containing formatting options.
+ * @returns The processed value with matched substrings removed.
+ *
+ * @example
+ * ```typescript
+ * import { regex } from './path/to/formatterFunctions';
+ *
+ * const processedValue = regex('abc123def456', { regex: '\\d+' });
+ * console.log(processedValue); // Output: 'abcdef'
+ * ```
+ */
+export declare const regex: (value: unknown, formatters: TFormatters) => unknown;

package/src/formatters/splitter.d.ts

@@ -0,0 +1,17 @@
+import { TFormatters } from '../types/schema';
+/**
+ * Splits a string by inserting specified values at given positions.
+ *
+ * @param value - The value to be processed.
+ * @param formatters - An object containing formatting options.
+ * @returns The processed value with splitters applied.
+ *
+ * @example
+ * ```typescript
+ * import { splitter } from './path/to/formatterFunctions';
+ *
+ * const processedValue = splitter('HelloWorld', { splitter: [{ position: 5, value: '_' }] });
+ * console.log(processedValue); // Output: 'Hello_World'
+ * ```
+ */
+export declare const splitter: (value: unknown, formatters: TFormatters) => unknown;

package/src/formatters/string.d.ts

@@ -0,0 +1,88 @@
+import { TFormatters } from '../types/schema';
+/**
+ * Capitalizes the first letter of a string.
+ *
+ * @param value - The value to be capitalized.
+ * @returns The value with the first letter capitalized.
+ *
+ * @example
+ * ```typescript
+ * import { capitalize } from './path/to/formatterFunctions';
+ *
+ * const capitalizedValue = capitalize('hello world');
+ * console.log(capitalizedValue); // Output: 'Hello world'
+ * ```
+ */
+export declare const capitalize: (value: unknown) => string;
+/**
+ * Converts a string to uppercase.
+ *
+ * @param value - The value to be converted.
+ * @returns The value in uppercase.
+ *
+ * @example
+ * ```typescript
+ * import { uppercase } from './path/to/formatterFunctions';
+ *
+ * const uppercasedValue = uppercase('hello world');
+ * console.log(uppercasedValue); // Output: 'HELLO WORLD'
+ * ```
+ */
+export declare const uppercase: (value: unknown) => string;
+/**
+ * Formats a string as a float number with a specific precision and decimal separator.
+ *
+ * @param value - The value to be formatted.
+ * @param formatters - An object containing formatting options.
+ * @returns The formatted float number.
+ *
+ * @example
+ * ```typescript
+ * import { onlyFloatNumber } from './path/to/formatterFunctions';
+ *
+ * const formattedNumber = onlyFloatNumber('1234567.89', { onlyFloatNumber: { precision: 2, decimal: '.' } });
+ * console.log(formattedNumber); // Output: '1234567.89'
+ * ```
+ */
+export declare const onlyFloatNumber: (value: unknown, formatters: TFormatters) => unknown;
+/**
+ * Trims whitespace from the beginning and end of a string.
+ *
+ * @param value - The value to be trimmed.
+ * @param formatters - An object containing formatting options.
+ * @returns The trimmed value.
+ *
+ * @example
+ * ```typescript
+ * import { trim } from './path/to/formatterFunctions';
+ *
+ * const trimmedValue = trim('   hello world   ');
+ * console.log(trimmedValue); // Output: 'hello world'
+ * ```
+ */
+export declare const trim: (value: unknown, formatters: TFormatters) => unknown;
+/**
+ * Truncates the input value to a specified maximum length if necessary.
+ *
+ * @param {string | number} value - The input value to be formatted.
+ * @param {TFormatters} formatters - An object containing formatting options.
+ * @param {number} formatters.maxLength - The maximum allowed length for the input value.
+ * @returns {string | number} - The formatted value truncated to the maximum length, if applicable.
+ *
+ * @example
+ * ```typescript
+ * const result = maxLength('Hello, World!', { maxLength: 5 });
+ * console.log(result); // "Hello"
+ * ```
+ * @example
+ * ```typescript
+ * const result = maxLength(123456789, { maxLength: 4 });
+ * console.log(result); // "1234"
+ * ```
+ * @example
+ * ```typescript
+ * const result = maxLength('Short', { maxLength: 10 });
+ * console.log(result); // "Short" (no truncation since input is shorter than maxLength)
+ * ```
+ */
+export declare const maxLength: (value: string | number, formatters: TFormatters) => string | number;

package/src/helpers/creditCard.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Represents the properties of a credit card type.
+ */
+export interface ICreditCardType {
+    /**
+     * A human-readable name for the credit card type.
+     * For example, "Visa", "Mastercard", "American Express", etc.
+     */
+    niceType: string;
+    /**
+     * A unique identifier for the credit card type.
+     * Typically, follows industry standards such as "visa", "mastercard", "amex", etc.
+     */
+    type: string;
+    /**
+     * An array of patterns (regular expressions) that match valid card numbers for this type.
+     * Each pattern corresponds to a specific length of card number.
+     */
+    patterns: number[] | [number[]];
+    /**
+     * An array representing the positions in the card number where spaces (gaps) should be added
+     * to format the number nicely. These positions are counted from the beginning of the number.
+     */
+    gaps: number[];
+    /**
+     * An array of possible lengths for valid card numbers of this type.
+     * Typically, this array contains only one element, but some card types may have multiple lengths.
+     */
+    lengths: number[];
+    /**
+     * Information about the card's security code (CVV/CVC/CID).
+     */
+    code: {
+        /**
+         * The size (length) of the security code for this card type.
+         */
+        size: number;
+        /**
+         * A descriptive name for the security code, such as "CVV" or "CVC".
+         */
+        name: string;
+    };
+    /**
+     * An optional value representing the match strength of the card type detection.
+     * Higher values indicate stronger matches, while lower values indicate weaker matches.
+     * This property is typically provided by the credit card type detection library.
+     */
+    matchStrength?: number;
+}
+/**
+ * Represents the return type of the `getTypeCard` function.
+ */
+export type TGetTypeCard = [ICreditCardType, string];
+/**
+ * Retrieves the type of the credit card and the raw value without spaces.
+ *
+ * @param value - The credit card number as a string.
+ * @param availableOptions - An optional array of credit card types to consider.
+ * @returns An array containing the detected credit card type and the raw value without spaces.
+ *
+ * @example
+ * ```typescript
+ * import { getTypeCard } from './path/to/helperFunctions';
+ *
+ * const [creditCardType, rawValue] = getTypeCard('4111 1111 1111 1111');
+ * console.log(creditCardType); // Output: { niceType: 'Visa', type: 'visa', ... }
+ * console.log(rawValue); // Output: '4111111111111111'
+ * ```
+ */
+export declare const getTypeCard: (value: string, availableOptions?: string[]) => TGetTypeCard;
+/**
+ * Formats a credit card number according to its type's gaps and lengths.
+ *
+ * @param value - The credit card number as a string.
+ * @param type - The type of the credit card.
+ * @returns The formatted credit card number.
+ */
+export declare const formatValue: (value: string, type: ICreditCardType) => string;
+/**
+ * Formats a date string by adding a prefix and/or trimming the string based on its length.
+ *
+ * @param value - The date string to be formatted.
+ * @param end - The ending index to slice the string to.
+ * @param prefix - The prefix to add between date components.
+ * @returns The formatted date string.
+ *
+ * @example
+ * ```typescript
+ * import { formatDateCard } from './path/to/helperFunctions';
+ *
+ * const formattedDate = formatDateCard('1223', 4, '/');
+ * console.log(formattedDate); // Output: '12/23'
+ * ```
+ */
+export declare const formatDateCard: (value: string, end?: number, prefix?: string) => string;

package/src/helpers/helpers.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+import { TSubscribedTemplates } from '../types/template';
+import { OutgoingHttpHeaders } from 'http2';
+/**
+ * Makes an HTTP request using XMLHttpRequest.
+ *
+ * @param {string} method - The HTTP method (GET, POST, PUT, DELETE, etc.).
+ * @param {string} url - The URL to which the request is sent.
+ * @param {OutgoingHttpHeaders} [headers] - Optional request headers.
+ * @param {Record<string,unknown>} [body] - Optional object body.
+ * @returns {Promise<string>} A promise that resolves with the response text if the request is successful, otherwise rejects with an error message.
+ *
+ * @example
+ * ```typescript
+ * const response = await makeRequest('GET', 'https://api.example.com/data');
+ * ```
+ */
+declare function makeRequest(method: string, url: string, headers?: OutgoingHttpHeaders, body?: Record<string, unknown>): Promise<string>;
+/**
+ * Extracts keys enclosed in `${}` from a given expression.
+ *
+ * @param {string} expression - The expression to extract keys from.
+ * @returns {
+ * originFieldKeys: string[];
+ * originPropertyKeys: string[];
+ * } An object containing the field names and properties from the template expression.
+ *
+ * @example
+ * ```typescript
+ * const keys = extractFieldKeys('Hello ${name.value}, your age is ${age.props.label}.');
+ * // keys will be {originFieldKeys:['name', 'age'],originPropertyKeys:[value,props]}
+ * ```
+ */
+declare function extractFieldKeys(expression: string): {
+    originFieldKeys: string[];
+    originPropertyKeys: string[];
+};
+/**
+ * Traverses an object and extracts expressions containing keys.
+ *
+ * @param {any} obj - The object to traverse.
+ * @param {string} [path] - Optional path within the object (used internally during recursion).
+ * @returns {TSubscribedTemplates[]} An array of extracted expressions along with their keys and paths.
+ *
+ * @example
+ * ```typescript
+ * const data = {
+ *   user: {
+ *     name: 'John',
+ *     age: 30,
+ *     address: {
+ *       street: '123 Main St',
+ *       city: 'Example City'
+ *     }
+ *   },
+ *   message: 'Hello ${user.name}, your age is ${user.age}.'
+ * };
+ *
+ * const expressions = traverseObject(data);
+ * // expressions will contain an array of objects with origin expressions, field keys, and destination paths.
+ * ```
+ */
+declare function traverseObject(obj: any, path?: string): TSubscribedTemplates[];
+export { makeRequest, traverseObject, extractFieldKeys };

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types/event';
+export * from './types/form';
+export * from './types/schema';
+export * from './types/template';
+export * from './types/mapper';
+export * from './interfaces/schema';
+export * from './interfaces/state';
+export * from './managers/form';
+export * from './managers/formGroup';
+export * from './managers/field';

package/src/interfaces/schema.d.ts

@@ -0,0 +1,82 @@
+import { TApiEvent, TErrorMessages, TEvent, TFormatters, TMasks, TProps, TResetValueMethods, TValidationMethods, TVisibility } from '../types/schema';
+/**
+ * @interface IComponentSchema
+ * Represents the schema for a component within a form.
+ *
+ * @property {string} component - The type of component (e.g., 'input', 'button').
+ * @property {TProps} props - The properties of the component.
+ * @property {string} name - The name of the component.
+ * @property {TEvent<TValidationMethods>} [validations] - The validation methods for the component.
+ * @property {TVisibility[]} [visibilityConditions] - The visibility conditions for the component.
+ * @property {TResetValueMethods[]} [resetValues] - The reset value methods for the component.
+ * @property {TErrorMessages} [errorMessages] - The error messages for the component.
+ * @property {TApiEvent} [api] - The API configuration for the component.
+ * @property {TFormatters} [formatters] - The formatters for the component.
+ * @property {TMasks} [masks] - The masks for the component.
+ * @property {IComponentSchema[]} [children] - The child components.
+ *
+ * @example
+ * ```typescript
+ * const schema: IComponentSchema = {
+ *   component: 'input',
+ *   props: { type: 'text', placeholder: 'Enter your name' },
+ *   name: 'name',
+ *   validations: { config: { required: true }, events: [{ eventName: 'ON_FIELD_BLUR' }] },
+ *   visibilityConditions: [{ conditions: { field: 'age', value: 18 } }],
+ *   resetValues: [{ field: 'age', resetTo: '' }],
+ *   errorMessages: { required: 'This field is required.' },
+ *   api: { defaultConfig: { config: { method: 'POST', url: 'https://api.example.com/submit' }, events: [{ eventName: 'ON_FORM_SUBMIT' }] } },
+ *   formatters: { capitalize: true },
+ *   masks: { currency: { align: 'left', decimal: '.', precision: 2, prefix: '$', thousands: ',' } },
+ *   children: []
+ * };
+ * ```
+ */
+interface IComponentSchema {
+    component: string;
+    props?: TProps;
+    name: string;
+    validations?: TEvent<TValidationMethods>;
+    api?: TApiEvent;
+    visibilityConditions?: TVisibility[];
+    resetValues?: TResetValueMethods[];
+    errorMessages?: TErrorMessages;
+    formatters?: TFormatters;
+    masks?: TMasks;
+    children?: IComponentSchema[];
+}
+/**
+ * @interface IFormSchema
+ * Represents the schema for a form.
+ *
+ * @property {string} index - The unique index or identifier for the form.
+ * @property {string} [action] - The URL to which the form data will be submitted.
+ * @property {string} [method] - The HTTP method used to submit the form (e.g., 'POST', 'GET').
+ * @property {Record<string, unknown>} [initialValues] - The initial values for the form fields.
+ * @property {Record<string, unknown>} [iVars] - Dynamic key value pairs that change from any external source
+ * @property {IComponentSchema[]} [components] - The list of components included in the form.
+ *
+ * @example
+ * ```typescript
+ * const formSchema: IFormSchema = {
+ *   index: 'userForm',
+ *   action: 'https://api.example.com/submit',
+ *   method: 'POST',
+ *   initialValues: { name: '', email: '' },
+ *   iVars: iVarsState,
+ *   components: [
+ *     { component: 'input', name: 'name', props: { placeholder: 'Enter your name' } },
+ *     { component: 'input', name: 'email', props: { placeholder: 'Enter your email' } }
+ *   ]
+ * };
+ * ```
+ */
+interface IFormSchema {
+    index: string;
+    action?: string;
+    method?: string;
+    initialValues?: Record<string, unknown>;
+    iVars?: Record<string, unknown>;
+    components?: IComponentSchema[];
+}
+export { IFormSchema, IComponentSchema };

package/src/interfaces/state.d.ts

@@ -0,0 +1,27 @@
+import { TApiResponse } from '../types/schema';
+/**
+ * @interface IState
+ * Represents the state of a form component.
+ *
+ * @property {string[]} errors - The list of error messages.
+ * @property {boolean} visibility - The visibility state of the component.
+ * @property {TApiResponse} apiResponse - The API response data.
+ * @property {Record<string, unknown>} props - The properties of the component.
+ *
+ * @example
+ * ```typescript
+ * const state: IState = {
+ *   errors: ['This field is required.'],
+ *   visibility: true,
+ *   apiResponse: { default: { response: null } },
+ *   props: { type: 'text', value: 'John' }
+ * };
+ * ```
+ */
+interface IState {
+    errors: string[];
+    visibility: boolean;
+    apiResponse: TApiResponse;
+    props: Record<string, unknown>;
+}
+export { IState };