@bolttech/form-engine-core 1.0.2-beta.1 → 1.0.2

package/src/formatters/string.d.ts

@@ -1,88 +0,0 @@
-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/SafeSubject.d.ts

@@ -1,11 +0,0 @@
-import { Subject } from 'rxjs';
-/**
- * Custom RXJS Subject to gracefully handle errors on unsubscribed Subjects
- * that were unmounted due to adapter external handling such as visibility
- */
-declare class SafeSubject<T> extends Subject<T> {
-    private isMounted;
-    constructor(isMounted: () => boolean);
-    next(value: T): void;
-}
-export { SafeSubject };

package/src/helpers/creditCard.d.ts

@@ -1,95 +0,0 @@
-/**
- * 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

@@ -1,67 +0,0 @@
-/// <reference types="node" />
-import { TEMPLATE_AVALIABLE_SCOPES } from '../constants/constants';
-import { TApiResponsePayload } from '../types/schema';
-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>, queryParams?: Record<string, string>): Promise<TApiResponsePayload>;
-/**
- * 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): {
-    originScopeKeys: (typeof TEMPLATE_AVALIABLE_SCOPES)[number][];
-    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(element: any, path?: string): TSubscribedTemplates[];
-export { makeRequest, traverseObject, extractFieldKeys };

package/src/helpers/validation.d.ts

@@ -1,27 +0,0 @@
-import { TSchemaValidation, TValidationMethods } from '../types/schema';
-import { TValidationHandler } from '../types/utility';
-/**
- * @internal
- * Handles the validation of a given value based on specified validation methods and rules.
- *
- * @param {string | number | boolean | unknown} value - The value to be validated.
- * @param {TSchemaValidation} validations - The schema validations to be applied.
- * @param {TValidationHandler} methods - The validation handler methods.
- * @param {keyof TValidationMethods} key - The specific key of the validation method to be used.
- * @returns {boolean} - Returns true if the value passes the validation, otherwise false.
- *
- * @example
- * const value = 'example@example.com';
- * const validations = {
- *   required: true,
- *   customName: { email: true }
- * };
- * const methods = {
- *   email: (value) => /\S+@\S+\.\S+/.test(value)
- * };
- * const key = 'required';
- *
- * const isValid = handleValidation(value, validations, methods, key);
- * console.log(isValid); // Output: true
- */
-export default function handleValidation(value: string | number | boolean | unknown, validations: TSchemaValidation, methods: TValidationHandler, key: keyof TValidationMethods): boolean;

package/src/index.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,112 +0,0 @@
-import { TMapper } from '../types/mapper';
-import { TApiEvent, TFormatters, TMasks, TProps, TResetPathMethods, TResetValueMethods, TSchemaFormConfig, TValidations, 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 {string} nameToSubmit - The name of the field when submit values (optional).
- * @property {TValidations} [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 {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.
- * @property {boolean} visibility - visibility status the component will mount (to avoid SSR blinking)
- * @property {boolean} persistValue - check this if you want the last visible value to be restored after a visiblity schema rule applied
- *
- * @example
- * ```typescript
- * const schema: IComponentSchema = {
- *   component: 'input',
- *   props: { type: 'text', placeholder: 'Enter your name' },
- *   name: 'name',
- *   nameToSubmit: 'applicant.firstName',
- *   validations: {
- *     methods: {
- *       required: true,
- *       regex: '^([0-9]+)*$',
- *       max: 5,
- *     },
- *     eventMessages: {
- *       ON_FIELD_MOUNT: ['required'],
- *       ON_FIELD_CHANGE: ['regex', 'required'],
- *       ON_FIELD_BLUR: ['max', 'required'],
- *     },
- *     messages: {
- *       default: 'This field is required',
- *       regex: 'Only numbers are available.',
- *       max: 'Max of 5',
- *     },
- *   },
- *   visibilityConditions: [{ conditions: { field: 'age', value: 18 } }],
- *   resetValues: [{ field: 'age', resetTo: '' }],
- *   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: [],
- *   visibility: true,
- *   persistValue: true,
- * };
- * ```
- */
-interface IComponentSchema {
-    component: string;
-    props?: TProps;
-    name: string;
-    nameToSubmit?: string;
-    validations?: TValidations;
-    api?: TApiEvent;
-    visibilityConditions?: TVisibility[];
-    resetValues?: TResetValueMethods[];
-    resetPropertyValues?: TResetPathMethods[];
-    formatters?: TFormatters;
-    masks?: TMasks;
-    children?: IComponentSchema[];
-    visibility?: boolean;
-    persistValue?: boolean;
-}
-interface IComponentSchemaAsFormField<T> extends IComponentSchema {
-    mapper?: TMapper<T>;
-    order?: number;
-    children?: IComponentSchemaAsFormField<T>[];
-}
-/**
- * @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;
-    config?: TSchemaFormConfig;
-    initialValues?: Record<string, unknown>;
-    iVars?: Record<string, unknown>;
-    components?: IComponentSchema[];
-}
-export { IFormSchema, IComponentSchema, IComponentSchemaAsFormField };

package/src/interfaces/state.d.ts

@@ -1,22 +0,0 @@
-/**
- * @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 {Record<string, unknown>} props - The properties of the component.
- *
- * @example
- * ```typescript
- * const state: IState = {
- *   visibility: true,
- *   props: { type: 'text', value: 'John' }
- * };
- * ```
- */
-interface IState {
-    visibility: boolean;
-    props: Record<string, unknown>;
-    errors: Record<string, unknown>;
-}
-export { IState };