@bolttech/form-engine 0.1.0

package/src/adapters/react/types.d.ts

@@ -0,0 +1,185 @@
+import { ReactElement } from 'react';
+import { TComponent, TErrorMessages, TSchemaValidation, TSchemaValidations, TSchema, THooks, TIVars, TFormValues, TField, TChildrenOptions, TPropsMapping, TComponentPropsMapping, TScope } from '@core/types';
+import { TLoggingEvent } from '@core/events/events.types';
+declare type TFormProps = {
+    /**
+     * Allow to set the form as read only mode.
+     *
+     * This will prevent any interaction with the form whatsoever
+     */
+    disable?: boolean;
+    /**
+     * Allow to specify a logical group across several forms so that we can get data with useFormGroup
+     */
+    group?: string;
+    /**
+     * Hooks to run on some life-cycles
+     */
+    hooks?: THooks;
+    /**
+     * Form id. Will default to a internal one in case not given
+     */
+    id?: string;
+    /**
+     * Internal variables. This object will be used in the global scope
+     * namespace
+     */
+    iVars?: TIVars;
+    /**
+     * Form initial values. This must map into form known fields
+     */
+    initialValues?: Record<string, unknown>;
+    /**
+     * Form schema that should contain form definition
+     */
+    schema?: TSchema;
+    /**
+     * HTML autocomplete form prop
+     */
+    autoComplete?: string;
+    /**
+     * ClassName in case you want to style form
+     */
+    className?: string;
+    /**
+     *
+     * Callback function that will run on each submit.
+     *
+     * NOTE: By default this function only runs if the form has no errors. If you
+     * want different behaviour, use submitOnValidOnly and set to false
+     *
+     * @param form - HTML original event
+     * @param values - Form generated value. Refer to its type
+     */
+    onSubmit?(form: React.FormEvent<HTMLFormElement>, values: TFormValues): Promise<Record<string, unknown> | void> | Record<string, unknown> | void;
+    /**
+     *
+     * Callback function that runs on each data change.
+     *
+     * You can who changed the data accessing to the arguments
+     *
+     * @param values - Form generated values
+     * @param component - The component configuration of the field that changed
+     * @param field - The current state of the changing field
+     */
+    onData?(values: TFormValues, component?: TComponent, field?: TField): void;
+    /**
+     *
+     * Callback function that runs on each blur.
+     *
+     * You can what field was blurred accessing to the arguments
+     *
+     * @param values - Form generated values
+     * @param component - The component configuration of the field that was blurred
+     * @param field - The current state of the blurred field
+     */
+    onBlur?(values: TFormValues, component?: TComponent, field?: TField): void;
+    /**
+     *
+     * Callback function that runs on each focus.
+     *
+     * You can what field was focused accessing to the arguments
+     *
+     * @param values - Form generated values
+     * @param component - The component configuration of the field that was focused
+     * @param field - The current state of the focused field
+     */
+    onFocus?(values: TFormValues, component?: TComponent, field?: TField): void;
+    /**
+     *
+     * Callback that tells you when a given field was mounted
+     *
+     * @param values - Form generated values
+     * @param component - The component configuration of the field that was mounted
+     * @param field - The current state of the mounted field
+     */
+    onFieldMount?(values: TFormValues, component?: TComponent, field?: TField): void;
+    /**
+     *
+     * This callback will be fired in each step change
+     *
+     * @param values - Form generated values
+     */
+    onStep?(values: TFormValues): void;
+    /**
+     * Enables you to see what is happening under the hood. Subscribing the callback will enable logging
+     *
+     * @param log - Logging event
+     */
+    onLog?(log: TLoggingEvent): void;
+    /**
+     *
+     * Notifies you about each form scope change and about who changed it
+     *
+     * @param scope - Form current scope with the update
+     * @param namespace - The namespace that was updated
+     * @param key - The key responsible for the update
+     */
+    onScopeChange?(scope: TScope, namespace: string, key: string): void;
+    /**
+     *
+     * When a given field is rehydrated, this callback will be called
+     *
+     * @param values - Form generated values
+     * @param component - The component configuration of the field that was mounted
+     * @param field - The current state of the mounted field
+     */
+    onFieldRehydrate?(values: TFormValues, component: TComponent, field: TField): void;
+    /**
+     * Allows you to pass a JSX so that the form shows it before rendering your schema
+     *
+     * @returns JSX
+     */
+    renderLoading?(): ReactElement;
+    /**
+     * Called when the form was mounted
+     *
+     * @param values - Form generated values
+     */
+    onFormMount?(values: TFormValues): void;
+    children?: ReactElement | ReactElement[];
+    /**
+     * Object to be used if you want to control the default values of the form.
+     *
+     * InitialValues will take precedence over this
+     */
+    formattedDataDefaults?: Record<string, unknown>;
+    /**
+     * Override the default form behaviour witch is to prevent submit when there is an error
+     */
+    submitOnValidOnly?: boolean;
+    /**
+     * Allows to insert a wrapper for each field or replace the field rendering
+     */
+    renderFieldWrapper?(component: TComponent, children: ReactElement[]): ReactElement;
+};
+declare type TMapper = Record<string, Record<string, unknown>>;
+declare type TProvider = {
+    children?: ReactElement | ReactElement[] | string;
+    mapper: TMapper;
+    propsMapping: TPropsMapping;
+};
+declare type TContext = {
+    mapper: TMapper;
+    propsMapping: TPropsMapping;
+};
+declare type TChildWrapperProps = {
+    children: ReactElement | ReactElement[];
+    component: TComponent;
+    wrapper: new () => React.Component;
+    propsMapping: TComponentPropsMapping;
+    formId?: string;
+    onMount(values: TField): void;
+    onChange(values: TField): void;
+    onRehydrate(values: TField): void;
+    onFocus(values: TField): void;
+    onBlur(values: TField): void;
+};
+declare type TFormRefActions = {
+    submit(): void;
+    stepForward(): TFormValues;
+    stepBack(): TFormValues;
+    validateForm(opts?: TChildrenOptions): TFormValues;
+    values(opts: Pick<TChildrenOptions, 'scopeBlurredChildren' | 'scopeChangedChildren' | 'childrenScope'>): TFormValues;
+};
+export type { TComponent, TMapper, TChildrenOptions, TFormValues, TFormRefActions, TChildWrapperProps, TContext, TFormProps, TProvider, TErrorMessages, TSchemaValidation, TSchemaValidations, };

package/src/adapters/react/useForceUpdate.d.ts

@@ -0,0 +1,3 @@
+declare type TProps = [value: unknown, dispatch: () => void];
+declare const useForceUpdate: () => TProps;
+export { useForceUpdate };

package/src/adapters/react/useForm.d.ts

@@ -0,0 +1,51 @@
+import { TChildrenOptions, TFormValues } from '@react/types';
+import { TField } from '@core';
+declare type TProps = {
+    /**
+     * The if of the form you want to connect to
+     */
+    id?: string;
+    /**
+     * And array of ids of forms you want to connect to
+     */
+    ids?: string[];
+    /**
+     * Callback to be called when form validity toggled
+     * @param data All the available form data
+     * @param field
+     */
+    onValid?(data: TFormValues, field: TField): void;
+    /**
+     * Callback to be called when the form generates some new data
+     * @param data All the available form data
+     */
+    onData?(data: TFormValues): void;
+    /**
+     * Callback to be called when the form submits
+     * @param data All the available form data
+     */
+    onSubmit?(data: TFormValues): void;
+};
+declare type THookReturn = {
+    /**
+     * A function that lets you start the form submission
+     */
+    submitForm(): void;
+    /**
+     * You can call this function to get all the updated form data
+     *
+     * @param opts Options to configure your form data
+     */
+    formData(opts?: TChildrenOptions): TFormValues;
+};
+/**
+ * This hooks lets you connect to your form/s in anywherer in your application. Even if you are outside the <FormProvider />
+ *
+ * You can connect to:
+ * - A specific form
+ * - Several forms identified by their id's
+ * - A group of forms
+ *
+ */
+declare const useForm: ({ onValid, onData, onSubmit, id, ids, }: TProps) => THookReturn;
+export default useForm;

package/src/adapters/react/useFormGroup.d.ts

@@ -0,0 +1,15 @@
+import { TChildrenOptions, TFormValues } from '@react/types';
+declare type TProps = {
+    ids?: string[];
+    group?: string;
+    onData?(data: Record<string, TFormValues>): void;
+    onSubmit?(data: Record<string, TFormValues>): void;
+};
+declare type THookReturn = {
+    submitForm(): void;
+    formData(opts?: TChildrenOptions & {
+        aggregate?: boolean;
+    }): Record<string, TFormValues>;
+};
+declare const useFormGroup: ({ group, onData, onSubmit, ids, }: TProps) => THookReturn;
+export { useFormGroup };

package/src/core/apis/formatters.d.ts

@@ -0,0 +1,16 @@
+/**
+ *
+ * This file will allow to expose functions to be used as formatters in schema and HOC
+ *
+ * Since it is a formatter, you can also expose its "undo" function that will allow form to make logic on the value without the
+ * formatter applied
+ *
+ * EG:
+ * splitter -> 22/33/4444
+ * undo_splitter -> 22334444
+ *
+ * This undo will be called when the form is filtering the data on the input if it has formatters configured
+ */
+import { TSchemaFormatters } from '@core/types';
+declare const run: (value: any, componentFormatters: TSchemaFormatters, undo?: boolean) => string | number;
+export { run };

package/src/core/apis/index.d.ts

@@ -0,0 +1,4 @@
+export * as formatters from '@core/apis/formatters';
+export * as masks from '@core/apis/masks';
+export * as validations from '@core/apis/validations';
+export * as varOps from '@core/apis/varOps';

package/src/core/apis/masks.d.ts

@@ -0,0 +1,3 @@
+import { TComponentMasks } from '@core/types';
+declare const run: (value: any, componentMasks: TComponentMasks) => string;
+export { run };

package/src/core/apis/validations.d.ts

@@ -0,0 +1,11 @@
+import { TErrorMessages, TErrors, TFieldData, TVAvailableValidations } from '@core/types';
+declare type TRuleValue = string | number | boolean | undefined;
+export interface ICustomValidationValue {
+    from: number;
+    to: number;
+    validations: Record<string, any>;
+}
+declare const run: (value: TRuleValue, rules: TVAvailableValidations, errorMessages?: TErrorMessages, formData?: TFieldData) => TErrors;
+declare const generateCustomError: (name: string, message: string) => TErrors;
+declare const hasError: (errors?: TErrors) => boolean;
+export { run, generateCustomError, hasError };

package/src/core/apis/varOps.d.ts

@@ -0,0 +1,4 @@
+export declare const concatenate: (a: any, b: any) => any;
+export declare const add: (a: any, b: any) => string;
+export declare const subtract: (a: any, b: any) => number;
+export declare const replaceAll: (value: string, searchValue: string, replaceValue: string) => string;

package/src/core/constants/events.d.ts

@@ -0,0 +1,23 @@
+import { TEventsKeys } from '@core/types';
+export declare const enum EEVents {
+    ON_FIELD_VALIDATION_TOGGLE = "ON_FIELD_VALIDATION_TOGGLE",
+    ON_FIELD_MOUNT = "ON_FIELD_MOUNT",
+    ON_FIELD_CHANGE = "ON_FIELD_CHANGE",
+    ON_FIELD_BLUR = "ON_FIELD_BLUR",
+    ON_FIELD_FOCUS = "ON_FIELD_FOCUS",
+    ON_FIELD_REHYDRATE = "ON_FIELD_REHYDRATE",
+    RUN_FIELD_VALIDATIONS = "RUN_FIELD_VALIDATIONS",
+    RUN_FIELD_MASKS = "RUN_FIELD_MASKS",
+    RUN_FIELD_FORMATTERS = "RUN_FIELD_FORMATTERS",
+    ON_SCOPE_CHANGE = "ON_SCOPE_CHANGE",
+    ON_FORM_REHYDRATE = "ON_FORM_REHYDRATE",
+    ON_FORM_SUBMIT = "ON_FORM_SUBMIT",
+    ON_FORM_MOUNT = "ON_FORM_MOUNT",
+    ON_FORM_UN_MOUNT = "ON_FORM_UN_MOUNT",
+    ON_FORM_DATA = "ON_FORM_DATA",
+    NAVIGATE_STEP_FORWARD = "NAVIGATE_STEP_FORWARD",
+    NAVIGATE_STEP_BACK = "NAVIGATE_STEP_BACK",
+    VALIDATE_FORM = "VALIDATE_FORM",
+    LOG = "LOG"
+}
+export declare const CoreEvents: Record<TEventsKeys, TEventsKeys>;

package/src/core/constants/index.d.ts

@@ -0,0 +1,5 @@
+declare const DEFAULT_FORM_ID = "default_form_id";
+declare const DEFAULT_FORM_HOOK_ID = "default_form_hook_id";
+export { ALL_NAMESPACE_EVENTS, BUILD_EVENT, EXTRACT_EVENT_NAMESPACE, EXTRACT_CORE_NAMESPACE, } from '@core/constants/observer';
+export { CoreEvents, EEVents } from '@core/constants/events';
+export { DEFAULT_FORM_ID, DEFAULT_FORM_HOOK_ID };

package/src/core/constants/observer.d.ts

@@ -0,0 +1,7 @@
+import { TEventsKeys } from '@core';
+import { EEVents } from '@core/constants';
+declare const EXTRACT_EVENT_NAMESPACE: (event: TEventsKeys) => EEVents;
+declare const BUILD_EVENT: (event: EEVents, namespace?: string, key?: string) => EEVents;
+declare const ALL_NAMESPACE_EVENTS: (event: TEventsKeys) => EEVents;
+declare const EXTRACT_CORE_NAMESPACE: (event: TEventsKeys) => EEVents;
+export { ALL_NAMESPACE_EVENTS, BUILD_EVENT, EXTRACT_EVENT_NAMESPACE, EXTRACT_CORE_NAMESPACE, };

package/src/core/events/ObserverError.d.ts

@@ -0,0 +1,7 @@
+declare class ObserverError extends Error {
+    breaksObservingChain: boolean;
+    constructor(message: any, { breaksObservingChain }: {
+        breaksObservingChain: any;
+    });
+}
+export { ObserverError };

package/src/core/events/events.types.d.ts

@@ -0,0 +1,27 @@
+import Field from '@core/managers/Field';
+import { Form } from '@core/managers/Form';
+import { TEventReducedSchema, TEventsKeys, TFormEventDirectives, TObserverData } from '@core/types';
+export declare type TEventPublishPayload = {
+    checksum?: string;
+} & {
+    [key in string]?: unknown;
+};
+export declare type TEventInformation = TObserverData & {
+    eventReducedSchema: TEventReducedSchema;
+    formEventDirectives: TFormEventDirectives;
+    form: Form;
+    field: Field;
+    coreEvent: TEventsKeys;
+};
+export declare enum EFlowLogging {
+    OBSERVER = "OBSERVER",
+    REACT_FIELD_ADAPTER = "REACT FIELD ADAPTER",
+    FIELD_HANDLER = "FIELD HANDLER"
+}
+export declare type TLoggingEvent = {
+    level: 'error' | 'info';
+    data?: any;
+    flow: EFlowLogging;
+    action: string;
+    error?: any;
+};

package/src/core/events/index.d.ts

@@ -0,0 +1,2 @@
+export { Observer } from '@core/managers/Factory';
+export { TEventInformation } from '@core/events/events.types';

package/src/core/handlers/common/templating.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ field, form, }: Pick<Events.TEventInformation, 'form' | 'field'>) => void;

package/src/core/handlers/field/api.d.ts

@@ -0,0 +1,4 @@
+import { TComponent } from '@core';
+import * as Events from '@core/events';
+export declare const handler: ({ field, form, eventReducedSchema: { api }, }: Pick<Events.TEventInformation, 'form' | 'field' | 'eventReducedSchema'>) => void;
+export declare const events: (component: TComponent) => string[];

package/src/core/handlers/field/blur.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ field, }: Pick<Events.TEventInformation, 'field' | 'eventReducedSchema'>) => void;

package/src/core/handlers/field/change.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ field, data, }: Pick<Events.TEventInformation, 'field' | 'data'>) => void;

package/src/core/handlers/field/clearFields.d.ts

@@ -0,0 +1,4 @@
+import * as Events from '@core/events';
+import { TComponent } from '@core';
+export declare const handler: ({ form, eventReducedSchema, }: Pick<Events.TEventInformation, 'form' | 'eventReducedSchema' | 'field'>) => void;
+export declare const events: (component: TComponent) => string[];

package/src/core/handlers/field/data.d.ts

@@ -0,0 +1,3 @@
+import { TFormValues } from '@core';
+import { TEventInformation } from '@core/events';
+export declare const handler: ({ form, field, }: Pick<TEventInformation, 'form' | 'field'>) => TFormValues;

package/src/core/handlers/field/filter.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ field, data, eventReducedSchema: { formatters }, }: Events.TEventInformation) => void;

package/src/core/handlers/field/focus.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ field }: Pick<Events.TEventInformation, 'field'>) => void;

package/src/core/handlers/field/formatters.d.ts

@@ -0,0 +1,4 @@
+import { TComponent } from '@core';
+import { TEventInformation } from '@core/events';
+export declare const handler: ({ data, field, eventReducedSchema: { formatters }, }: TEventInformation) => void;
+export declare const events: (component: TComponent) => string[];

package/src/core/handlers/field/htmlEventParser.d.ts

@@ -0,0 +1,6 @@
+import { TEventInformation } from '@core/events';
+export declare const handler: ({ field, data: { event } }: TEventInformation) => {
+    parsedEventValue: any;
+    metadata: any;
+    isDeletingValue: boolean;
+};

package/src/core/handlers/field/masks.d.ts

@@ -0,0 +1,4 @@
+import { TComponent } from '@core';
+import * as Events from '@core/events';
+export declare const handler: ({ field, eventReducedSchema: { masks }, }: Events.TEventInformation) => void;
+export declare const events: (component: TComponent) => string[];

package/src/core/handlers/field/mount.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ form, field, }: Pick<Events.TEventInformation, 'form' | 'field'>) => void;

package/src/core/handlers/field/validations.d.ts

@@ -0,0 +1,4 @@
+import { TComponent } from '@core';
+import * as Events from '@core/events';
+export declare const handler: ({ field, eventReducedSchema: { validations }, form, }: Events.TEventInformation) => void;
+export declare const events: (component: TComponent) => string[];

package/src/core/handlers/field/visibilityConditions.d.ts

@@ -0,0 +1,4 @@
+import * as Events from '@core/events';
+import { TComponent } from '@core';
+export declare const handler: ({ form, field, eventReducedSchema, }: Pick<Events.TEventInformation, 'form' | 'field' | 'eventReducedSchema'>) => void;
+export declare const events: (component: TComponent) => string[];

package/src/core/handlers/flows.d.ts

@@ -0,0 +1,36 @@
+import { TSchema } from '@core';
+import * as Events from '@core/events';
+import * as change from '@core/handlers/field/change';
+import * as mount from '@core/handlers/field/mount';
+import * as blur from '@core/handlers/field/blur';
+import * as focus from '@core/handlers/field/focus';
+import * as templating from './common/templating';
+import * as api from '@core/handlers/field/api';
+import * as data from '@core/handlers/field/data';
+import * as validations from '@core/handlers/field/validations';
+import * as hooks from '@core/handlers/form/hooks';
+import * as steps from '@core/handlers/form/steps';
+import * as validate from '@core/handlers/form/validate';
+import * as formLevelVisibilityConditions from '@core/handlers/form/visibilityConditions';
+import * as formTemplating from '@core/handlers/form/templating';
+declare const register: (observer: Events.Observer, flows: any, component?: any | TSchema) => void;
+declare const fieldFlows: () => {
+    ON_FIELD_MOUNT: (typeof mount)[];
+    ON_FIELD_CHANGE: (typeof change | typeof api | typeof data)[];
+    ON_FIELD_REHYDRATE: (typeof validations)[];
+    ON_FIELD_BLUR: (typeof blur | typeof data)[];
+    ON_FIELD_FOCUS: (typeof focus)[];
+};
+declare const formFlows: () => {
+    [x: string]: (typeof formTemplating)[];
+    ON_SCOPE_CHANGE: (typeof formTemplating)[];
+    ON_FORM_MOUNT: (typeof templating | typeof steps | typeof validate | typeof formLevelVisibilityConditions)[];
+    VALIDATE_FORM: (typeof validate)[];
+    ON_FORM_SUBMIT: (typeof hooks)[];
+    ON_FORM_UN_MOUNT: (typeof hooks)[];
+    NAVIGATE_STEP_BACK: (typeof steps)[];
+    NAVIGATE_STEP_FORWARD: (typeof steps)[];
+    ON_FORM_REHYDRATE: (typeof formLevelVisibilityConditions)[];
+    ON_FIELD_CHANGE: (typeof formLevelVisibilityConditions)[];
+};
+export { register, fieldFlows, formFlows };

package/src/core/handlers/form/hooks.d.ts

@@ -0,0 +1,3 @@
+import { TEventInformation } from '@core/events';
+import { THookPayload } from '@core/types';
+export declare const handler: ({ form, }: Pick<TEventInformation, 'form'>) => THookPayload;

package/src/core/handlers/form/steps.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ form, event, }: Pick<Events.TEventInformation, 'form' | 'event'>) => void;

package/src/core/handlers/form/templating.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ form }: Pick<Events.TEventInformation, 'form'>) => void;

package/src/core/handlers/form/validate.d.ts

@@ -0,0 +1,2 @@
+import * as Events from '@core/events';
+export declare const handler: ({ form, payload, }: Pick<Events.TEventInformation, 'form' | 'payload'>) => void;

package/src/core/handlers/form/visibilityConditions.d.ts

@@ -0,0 +1,4 @@
+import { TSchema } from '@core';
+import { TEventInformation } from '@core/events';
+export declare const handler: ({ form, formEventDirectives, }: Pick<TEventInformation, 'form' | 'formEventDirectives'>) => void;
+export declare const events: (schema: TSchema) => string[];

package/src/core/index.d.ts

@@ -0,0 +1,3 @@
+export type { TFormRefActions, TFormValues, TSchema, TComponent, TField, TEventsKeys, TObserverData, } from '@core/types';
+export { TAvailableHooks } from '@core/types';
+export { ALL_NAMESPACE_EVENTS, BUILD_EVENT, EXTRACT_EVENT_NAMESPACE, CoreEvents, } from '@core/constants';

package/src/core/managers/Base.d.ts

@@ -0,0 +1,19 @@
+import { Observer } from '@core/events';
+import { EFlowLogging, TEventPublishPayload } from '@core/events/events.types';
+import { TEventsKeys } from '@core';
+declare class Base {
+    #private;
+    subscriptions: {
+        [x in TEventsKeys]?: () => void;
+    };
+    debounceTime: number;
+    constructor(observer: Observer);
+    subscribe(event: TEventsKeys, cb: (...data: any) => void): void;
+    subscribeBulk(events: TEventsKeys[], cb: (...data: any) => void): void;
+    publish(events: TEventsKeys, data?: TEventPublishPayload): void;
+    publishFor(events: TEventsKeys): any;
+    debounce: (fn: any, debounceTime?: number) => Promise<unknown>;
+    logError(file: EFlowLogging, event: string, method: string, error: unknown): void;
+    logInfo(file: EFlowLogging, event: string, method: string, extraData?: unknown): void;
+}
+export default Base;

package/src/core/managers/Factory.d.ts

@@ -0,0 +1,52 @@
+import Form from '@core/managers/Form';
+import { IObservable, TEvents, TEventsKeys, TObservable, TSchema, TScope } from '@core/types';
+import { EEVents } from '@core/constants';
+import { TEventPublishPayload, TLoggingEvent } from '@core/events/events.types';
+declare class Observer implements IObservable {
+    #private;
+    regexBasedEvents: Record<string, {
+        regex: RegExp;
+        handlers: TObservable[];
+    }>;
+    events: TEvents;
+    history: {
+        [key in EEVents]?: string;
+    };
+    namespace: string;
+    enableLogging: boolean;
+    constructor(namespace: string, enableLogging?: boolean);
+    runForRegexBasedEvent(eventName: any, cb: (event: TEventsKeys) => void): boolean;
+    handleRegexSubscription(eventName: any, handler: TObservable): void;
+    /**
+     * This function lets you subscribe to a given event and register one callback to be called when someone published in it
+     *
+     * The callback you redister will, return you the published data and one function to unregister your callback from that event
+     *
+     */
+    subscribe(eventName: TEventsKeys, handler: TObservable): () => void;
+    unsubscribe(eventName: TEventsKeys, handler: TObservable): void;
+    isAsyncFunction(fn: (...data: any) => any): boolean;
+    /**
+     * Allows to publish data to a given event name
+     *
+     * Will iterate the subscriptions and call their handlers.
+     *
+     * When calling the handler, will also inject the unsubscribe function
+     *
+     * This methods also accepts one regex and will find the matchin events and
+     * publish in them
+     *
+     */
+    publish(eventName: TEventsKeys, data?: TEventPublishPayload): Promise<{}>;
+    publishForEvents(eventName: TEventsKeys, data: {}, events: TEvents): Promise<{}>;
+    logError(flow: Pick<TLoggingEvent, 'flow'>['flow'], event: string, method: string, error: unknown): void;
+    logInfo(flow: Pick<TLoggingEvent, 'flow'>['flow'], event: string, method: string, extraData?: any): void;
+}
+export declare const getFormInstance: (namespace?: string, opts?: {
+    schema?: TSchema;
+    initialScope?: TScope;
+    initialValues?: Record<string, any>;
+    newInstance?: boolean;
+    group?: string;
+}) => Form, getGroupFormsIds: (group: string) => string[];
+export { Observer };

package/src/core/managers/Field.d.ts

@@ -0,0 +1,31 @@
+import * as Events from '@core/events';
+import { TField, TComponent, TErrors, TComponentPropsMapping, TEventReducedSchema, TEventsKeys } from '@core/types';
+import Scope from '@core/managers/Scope';
+import Base from '@core/managers/Base';
+declare class Field extends Base {
+    #private;
+    scope: Scope;
+    constructor(observer: Events.Observer, component: TComponent, propsMapping: TComponentPropsMapping, scope: Scope);
+    get value(): any;
+    set value(value: any);
+    get component(): TComponent;
+    get data(): TField;
+    set data(data: TField);
+    set visibility(visible: boolean);
+    get scopedComponent(): TComponent;
+    set scopedComponent(component: TComponent);
+    get errors(): TErrors;
+    set errors(errors: TErrors);
+    get props(): Record<string, unknown>;
+    get mappings(): TComponentPropsMapping;
+    getFieldErrorMessages(data?: TField): string[];
+    fieldHasError(errors?: TErrors): boolean;
+    fieldValidationsHaveError(setErrorMessages?: boolean): boolean;
+    /**
+     *
+      Calculates and returns the version of the current scoped object for a given event
+     */
+    eventReducedSchema(event: TEventsKeys): TEventReducedSchema;
+    rehydrate(): void;
+}
+export default Field;