tuain-ng-forms-lib 17.3.6 → 17.4.0

package/README.md

@@ -1,411 +1,356 @@
+# tuain-ng-forms-lib
 
-# Tuain-ng-forms-lib
+UI-agnostic core of the Tuain platform's **dynamic forms** framework for Angular 17+.
 
-Angular library to support Tuain Framework Forms operation.
+It lets you build form-driven applications by rendering complete forms —fields, actions, tables and sections— from **JSON definitions sent by the server**, using a **reactive** programming model: each form is a class that declares *how it reacts* to UI events through callbacks, while the library takes care of instantiating the model, keeping the view in sync and orchestrating backend communication.
 
-## Installation
+> This library provides the **domain model**, the **abstract base components** and the **services**. It does not impose a UI library: concrete widgets are supplied by UI packages (e.g. `tuain-ng-forms-ant` with ng-zorro, `tuain-ng-forms-ionic` with Ionic) or by the application itself, by extending the base components.
 
-Use the package manager npm to install the library in your Angular 9 application
+## Table of contents
 
-```bash
-npm install tuain-ng-forms-lib
-```
+1. [Purpose and architecture](#1-purpose-and-architecture)
+2. [Services](#2-services)
+3. [Forms API and the reactive approach](#3-forms-api-and-the-reactive-approach)
+4. [Form lifecycle](#4-form-lifecycle)
+5. [Form composition and element access](#5-form-composition-and-element-access)
+6. [Model objects vs. view components](#6-model-objects-vs-view-components)
+7. [Using the library in an Angular project](#7-using-the-library-in-an-angular-project)
 
-## Usage
+---
 
-Import the library module in your own module, and include it in your imports and exports if you need to use it with your own components in other application modules.
+## 1. Purpose and architecture
 
-```typescript
-import { TuainNgFormsLibModule } from  'tuain-ng-forms-lib';
-
-...
-@NgModule({
-imports: [
-...
-TuainNgFormsLibModule,
-...,
-],
-declarations: [
-...
-],
-exports: [
-...
-TuainNgFormsLibModule,
-...
-],
-})
-```
+The goal is to **leverage the construction of form-based applications**: instead of hand-coding every screen, the server describes the form (fields, actions, tables, sections, states) as JSON and the library materializes it as a graph of live objects with reactive behavior. The application only writes the form's **business logic** (what to do when a field is validated, an action is executed, etc.).
 
-## Public API
-
-Tuain-ng-forms-lib expose a series of components and services to provide base clases to build forms in
-Angular applications following the Tuain Platforms standard behavior. The elements exposed by the API
-are described below.
+The architecture is organized in layers:
 
-| Element | Name |
-| ------ | ------ |
-| Component | ActionComponent |
-| Component | FieldComponent |
-| Component | PasswordComponent |
-| Component | ElementComponent |
-| Component | FormErrorComponent |
-| Component | FormHeaderComponent |
-| Component | SectionComponent |
-| Component | SubSectionComponent |
-| Component | LibTableFilterComponent |
-| Component | LibTablePagerComponent |
-| Component | LibTableRecordActionComponent |
-| Component | LibTableRecordFieldComponent |
-| Component | LibTableComponent |
-| Component | BasicFormComponent |
-| Service | LibFileManagementService |
-| Service | LibFormManagerService |
-| Service | IconDictionaryService |
+```
+┌──────────────────────────────────────────────────────────────────┐
+│  PRESENTATION LAYER (concrete UI)                                 │
+│  tuain-ng-forms-ant (ng-zorro) · tuain-ng-forms-ionic (Ionic)·App │
+│  Widgets that extend the base components and supply the template  │
+├──────────────────────────────────────────────────────────────────┤
+│  BASE COMPONENTS LAYER (abstract, standalone)                     │
+│  FieldComponent · ActionComponent · LibTableComponent · …         │
+│  Sync model→view via signals; translate UI events                 │
+├──────────────────────────────────────────────────────────────────┤
+│  MODEL LAYER (domain)                                             │
+│  FormStructureAndData · FieldDescriptor · FormAction · RecordTable │
+│  Form structure + data + state (live objects)                     │
+├──────────────────────────────────────────────────────────────────┤
+│  SERVICES LAYER                                                   │
+│  FormManager · EventManager · FileManagement · IconResolver · SSE │
+│  Server definition/actions, navigation, events, files             │
+└──────────────────────────────────────────────────────────────────┘
+                              │
+                              ▼
+                    Angular 17+ · RxJS
+```
 
-### Components
+Model hierarchy (each level adds capabilities):
 
-These components can be customized in your own application using inheritance to define your
-own components that behaves like these base components but with your own custom templates.
+```
+FormPiece                 visibility, enablement, states, customAttributes
+  └─ FormPiecePropagate   reactive attribute propagation (BehaviorSubject)
+      ├─ FormElement      elementType + setAttr() with propagation
+      │   ├─ FieldDescriptor   field: value, validation, options, errors
+      │   ├─ FormAction        action: backend, inProgress, restrictions
+      │   └─ RecordTable       table: columns, records, paging, filters
+      ├─ RecordFormSection     section (activation/navigation)
+      └─ RecordFormSubSection  subsection (groups elements)
+
+FormStructureAndData      form container (fields + actions + tables + state)
+  └─ BasicFormComponent   Angular component: lifecycle + callbacks + server
+```
 
-#### ActionComponent
+Every public entity also has a **contract interface** (`IForm`, `IField`, `IAction`, `ITable`, `ITableColumn`, `ITableAction`, `ISection`, …) implemented by the classes; applications may type against the contracts instead of the concrete classes.
 
-This componet allows to create elements in a form to launch the execution of an action
-present in the form definition.
+---
 
-##### Inputs
+## 2. Services
 
-This component allows to receive the following information
+Services decouple the core from each application's specifics. They are provided via DI; some are **abstract by design** (the app implements them).
 
-| Input Name | Description |
-| --- | ----------- |
-| actionObjec | Defines the action object of the form |
-| currentMode | Defines the current state of the form in order to define if the element can be visible or actionable |
-| busy | Defines in the form is makinh an exclusive process that prevents the action execution |
-| relatedField | Describe the field object related with this action |
-| style | Define a style attribute for the action |
-| showLabel | Define if the action shows it's label
+| Service / Token | Role | App implements? |
+| --- | --- | --- |
+| `LibFormManagerService` | Fetches the form definition (`getFormDefinition`), runs server actions (`execServerAction`), navigates between forms and manages the **navigation stack** (`openForm`, `backTo`, `stack`/`unstack`). | Yes (overrides the server/navigation methods) |
+| `LibEventManagerService` | The app's **event bus** (Subject / BehaviorSubject / ReplaySubject) for communication between forms and components. | Instantiated with its set of events |
+| `LibFileManagementService` | File handling (`openFile`, `saveFile`, `saveFileFromURL`, `printPdfFile`) per platform (web/mobile). | Yes |
+| `BaseIconResolverService` + `ICON_RESOLVER` | **Extensible, multi-collection** icon resolution (each UI registers its collections). | Optional (extend/register) |
+| `SseLiveConnectionService` + `SSE_LIVE_CONNECTION_CONFIG` | **Server→client** event channel over Server-Sent Events (native reconnection). All integration is provided through the config token. | Provides the config |
 
-##### Methods
+The core never assumes a concrete implementation: it defines the contract and the app satisfies it via `providers`.
 
-The action component has the following methods.
+---
 
-* activate: Allows to activate the action
-* icon: Returns the icon name of the action
-* isVisible: Informs if the action is visible in the form
+## 3. Forms API and the reactive approach
 
-#### FieldComponent
+An application form is a **class that extends `BasicFormComponent`**. The central idea of the reactive approach is that **you don't program the flow imperatively**; instead you *declare how the form reacts to UI events*, registering callbacks that the library invokes at the right moment.
 
-##### Inputs
+UI components don't call business logic directly: they translate the UI event into a notification on the **model object**, and `BasicFormComponent` —subscribed to that object— fires the callbacks the app registered.
 
-This component allows to receive the following information
+```
+  User types in the input
+        │  (template) (ngModelChange)
+        ▼
+  FieldComponent.inputChanged()
+        ├─ updateObject()      → field.setValue(...)      (view → model)
+        └─ onChangeContent()   → field.notifyEditionFinish()
+                                      │  emits on editionFinish (Subject)
+                                      ▼
+            BasicFormComponent.startFieldValidation(code)
+                                      │
+                                      ▼
+            callbacks registered with onFieldValidationStart(...)
+                                      │  (if ok and field.backend)
+                                      ▼
+            requestFormAction('VALIDATE')  → updateFormWithServerData()
+                                      ▼
+            callbacks registered with onFieldValidationFinish(...)
+```
 
-| Input Name | Description |
-| --- | ----------- |
-| fieldObject | |
-| currentMode | |
+Conversely, when the model changes (by code or by a server response) the view updates itself thanks to **reactive propagation**:
 
-##### Methods
+```
+  field.setValue(x)  →  setAttr()  →  propagateAttribute('value', x)
+        │                                   │  _attributeChange.next(...)  (BehaviorSubject)
+        │                                   ▼
+        │                    FieldComponent (subscribed to field.attributeChange)
+        │                                   ▼
+        │                         this.value.set(x)   (signal)  →  template
+```
 
-The field component has the following methods.
+### Registering callbacks (how the form "reacts")
 
-* focus: Allows to focus on the native element of the field, usig the subclass method
-* onInputChange: Allows to link the change on the native element with the form manager behavior
-* onChangeContent: Allows to link the typing on the native element with the form manager behavior
-* onShowInfo: Allows to link the show infor request on the component custom template with the
-form event handler defined to support the respective action request.
-* numberInputValidation: Allows to use the number input validation to restrict the typing
+Inside `start()` (or `preStart()`) the app registers the handlers:
 
-#### ElementComponent
+```typescript
+// Actions
+this.onActionStart('save', (action) => this.validateBeforeSaving());   // false cancels
+this.onActionFinish('save', (action, result) => this.notifySaved());
 
-##### Inputs
+// Fields
+this.onFieldValidationStart('email', (field) => this.preValidateEmail(field));
+this.onFieldValidationFinish('email', (field) => this.afterValidateEmail(field));
+this.onFieldInput('phone', (field) => this.formatWhileTyping(field));
 
-This component allows to receive the following information
+// Tables
+this.onTableActionStart('items', 'edit', (detail) => this.openEdition(detail));
+this.onTableGetDataFinish('items', (detail, result) => this.afterPaging(detail));
 
-| Input Name | Description |
-| --- | ----------- |
-| element | |
-| formManager | |
+// Sections and form
+this.onSectionActivation('data', (section) => this.onEnterSection(section));
+this.onFormChange((state) => this.onStateChanged(state));
 
-#### FormErrorComponent
+// Server errors
+this.onActionServerError((action) => this.showError());
+```
 
-##### Inputs
+Every callback that runs **before** the backend (`...Start`) can return `false` to **cancel** the flow. The `...Finish` ones run after the server part.
 
-This component allows to receive the following information
+---
 
-| Input Name | Description |
-| --- | ----------- |
-| errorTitle | |
-| errorMessage | |
-| errorType | |
+## 4. Form lifecycle
 
-#### FormHeaderComponent
+```
+ 1. Angular creates the form component (a BasicFormComponent subclass)
+ 2. ngOnInit() ─────────────► preStart()            (config hook: formCode, route)
+ 3. The app calls formInit(params):
+      a. processInputParams()            extracts token / subject / state from the stack
+      b. getFormDefinition(name)         requests the JSON from the server (FormManager)
+      c. loadDefinition(json) ──────────►  instantiates FieldDescriptor / FormAction /
+                                            RecordTable / RecordFormSection  (live model)
+      d. subscribeSectionActivation()
+         subscribeFieldsSubjects()        the library subscribes to each model object's
+         subscribeActionSubjects()        events and connects its state to the form's
+         subscribeTableSubjects()         (connectWithParentForm)
+      e. changeState(initialState)        state machine (visibility/editability)
+      f. requestFormAction('GETDATA')     initial data load (if loadInitialData)
+      g. start()                          app hook: callbacks are registered HERE
+ 4. Operation: the UI fires events → notifications on the model → callbacks
+ 5. Angular destroys the component → takeUntilDestroyed cleans up the subscriptions
+```
 
-##### Inputs
+Key points:
 
-This component allows to receive the following information
+- **`preStart()`**: configure `name` (the form code) and route parameters.
+- **`start()`**: register the callbacks (`on*`). Runs once the model is already loaded.
+- **`changeState(state)`**: the **state machine** defines, for each state, which fields/actions/tables are visible and editable (`visibleStates` / `enabledStates`). Changing state re-propagates visibility and enablement to the whole view.
+- **`requestFormAction(code)`**: the single point of backend communication; its response enters through `updateFormWithServerData()` and updates the existing fields/actions/tables via `updateFromServer()`.
 
-| Input Name | Description |
-| --- | ----------- |
-| formManager | |
-| icon | |
-| goBackAction | |
-| showTitle | |
-| headerActions | |
+---
 
-##### Ouputs
+## 5. Form composition and element access
 
-Como salidas de este componente se genera el siguiente evento que permite determinar que desde el encabezado se solicita al formulario cerrar su operación y regresar al formulario previo.
+`FormStructureAndData` (which `BasicFormComponent` extends) holds the form graph and exposes a **rich API** to access and manipulate its elements. Each element is obtained by its `code` and operated directly on the model object.
 
-| Input Event | Description |
-| --- | ----------- |
-| goBackEvent | |
+```typescript
+// Fields  → FieldDescriptor (IField)
+const email = this.getField('email');
+email.setValue('a@b.com');
+email.required = true;
+if (email.hasError()) { /* … */ }
+this.getFieldValue('email');                 // shortcut
+this.getRequiredEmptyFields(null, 'data');   // by section
+
+// Actions → FormAction (IAction)
+const save = this.getAction('save');
+this.disableAction('save');
+this.getHeaderActions();
+
+// Tables  → RecordTable (ITable), with columns and table actions
+const items = this.getTable('items');
+items.setTableRecords(records);
+items.getActions('INLINE');                  // ITableAction[]
+items.columns;                               // ITableColumn[]
+const rec = this.getTableRecord('items', id);// ITableRecord
+
+// Sections → RecordFormSection (ISection) / RecordFormSubSection (ISubSection)
+this.activateSection('data');
+this.getSubSection('data', 'personal');
+```
 
-#### SectionComponent
+Element ↔ component relationship:
 
-##### Inputs
+| Element (model) | Contract | Base view component |
+| --- | --- | --- |
+| `FieldDescriptor` | `IField` | `FieldComponent` |
+| `FormAction` | `IAction` | `ActionComponent` |
+| `RecordTable` | `ITable` | `LibTableComponent` |
+| `RecordTableColumn` / `TableAction` | `ITableColumn` / `ITableAction` | cells in `LibTableRecordFieldComponent` / `LibTableRecordActionComponent` |
+| `RecordFormSection` / `RecordFormSubSection` | `ISection` / `ISubSection` | `SectionComponent` / `SubSectionComponent` |
+| `FormStructureAndData` | `IForm` | `BasicFormComponent` / `FormHeaderComponent` |
 
-This component allows to receive the following information
+Each component receives its model object via `@Input()` (`[field]`, `[action]`, `[table]`, …), registers itself as that object's *widget* and **subscribes to its changes** to reflect them; and it translates user events into notifications on that same object. In other words, **the component is a view of the model object, not its owner**.
 
-######
+---
 
-#### SubSectionComponent
+## 6. Model objects vs. view components
 
-##### Inputs
+This is the most important distinction for using the library correctly:
 
-This component allows to receive the following information
+```
+   MODEL (lives for the whole form)            VIEW (ephemeral, created/destroyed by Angular)
+   ┌───────────────────────────┐               ┌───────────────────────────┐
+   │  FieldDescriptor 'email'  │◄── @Input ────│  FieldComponent           │
+   │  (created in loadDefinition│   field.widget │  (created when rendered)  │
+   │   lives until the form is  │◄── subscription│  signals: value(), …      │
+   │   closed)                 │   attributeChange   destroyed when hidden   │
+   └───────────────────────────┘               └───────────────────────────┘
+        ▲ source of truth                             ▲ recreated without losing data
+        │ getField('email') always returns the same object
+```
 
-| Input Name | Description |
-| --- | ----------- |
-| sectionObject | |
-| formManager | |
+- **Model objects** (`FieldDescriptor`, `FormAction`, `RecordTable`, …) are created **once** in `loadDefinition()` and **live for as long as the form exists**. They hold the state: value, errors, visibility, selection, etc. `getField('x')` **always returns the same instance**.
+- **Components** (`FieldComponent`, etc.) are **ephemeral**: Angular creates and destroys them based on what is currently shown (section change, `@if`, table paging, virtual scroll…). When destroyed and recreated, **nothing is lost**: the new component re-subscribes to the model object and recovers the current state.
 
-#### LibTableFilterComponent
+**Practical consequences:**
 
-##### Inputs
+- The form's business logic operates **on the model objects** (`this.getField('x').setValue(...)`), never on the components. It works even if the component is not mounted.
+- Don't keep state in the component expecting it to persist; state lives in the model.
+- A model object and its component **are not the same thing**: the component is a replaceable reactive projection of the object, whereas the object is the stable, unique entity.
 
-This component allows to receive the following information
+---
 
-| Input Name | Description |
-| --- | ----------- |
-| subSection | |
-| showHeader | |
-| formManager | |
+## 7. Using the library in an Angular project
 
-#### LibTablePagerComponent
+### Installation
 
-##### Inputs
+```bash
+npm install tuain-ng-forms-lib
+# or: yarn add tuain-ng-forms-lib
+```
 
-This component allows to receive the following information
+Peer dependencies: Angular `^17` (`common`, `core`, `forms`, `router`) and `rxjs ^7.5`.
 
-| Input Name | Description |
-| --- | ----------- |
-| table | |
-| visiblePages | |
-| pagesGroup | |
+### a. Provide the services
 
-##### Outputs
+Standalone apps register them in `main.ts` (or in an `NgModule` with `providers`):
 
-| Output Event | Description |
-| --- | ----------- |
-| pageChanged | |
+```typescript
+import { bootstrapApplication } from '@angular/platform-browser';
+import { LibFormManagerService, LibFileManagementService, LibEventManagerService } from 'tuain-ng-forms-lib';
+import { AppFormManager } from './services/app-form-manager.service';   // your implementation
+import { AppFileManager } from './services/app-file-manager.service';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    { provide: LibFormManagerService, useClass: AppFormManager },
+    { provide: LibFileManagementService, useClass: AppFileManager },
+    { provide: LibEventManagerService, useValue: new LibEventManagerService(['formActivity', /* … */]) },
+    // optional: ICON_RESOLVER, SSE_LIVE_CONNECTION_CONFIG
+  ],
+});
+```
 
-#### LibTableRecordActionComponent
+`AppFormManager` extends `LibFormManagerService` and implements the bridge to your backend:
 
-##### Inputs
+```typescript
+@Injectable()
+export class AppFormManager extends LibFormManagerService {
+  override async getFormDefinition(formCode: string): Promise<any> { /* HTTP → JSON */ }
+  override async execServerAction(detail: any): Promise<any> { /* HTTP → response */ }
+  override goToForm(formCode: string, token: string, subject: string | null): void { /* router */ }
+}
+```
 
-This component allows to receive the following information
+### b. Define a form
 
-######
+```typescript
+import { Component } from '@angular/core';
+import { BasicFormComponent, LibFormManagerService, LibEventManagerService, LibFileManagementService } from 'tuain-ng-forms-lib';
+import { appFormConfig } from './app-form.config';   // your IFormConfig
+
+@Component({ standalone: true, selector: 'app-customer-form', templateUrl: './customer-form.html' })
+export class CustomerFormComponent extends BasicFormComponent {
+  constructor(fm: LibFormManagerService, em: LibEventManagerService, fs: LibFileManagementService) {
+    super(fm, em, fs);
+    this.setConfig(appFormConfig);
+  }
+
+  override preStart(): void {
+    this.name = 'CUSTOMER';                 // form code
+    this.formInit({ /* route params */ });  // triggers load + initialization
+  }
+
+  override start(): void {
+    // Declare HOW the form reacts:
+    this.onFieldValidationStart('documentId', (f) => this.validateDocument(f));
+    this.onActionStart('save', () => this.validateSectionConsistency('data'));
+    this.onActionFinish('save', () => this.goBack());
+  }
+
+  private validateDocument(field /* IField */): boolean {
+    if (field.empty) { field.setErrorMessage('Required'); return false; }
+    return true;
+  }
+}
+```
 
-#### LibTableRecordFieldComponent
+### c. Render
 
-##### Inputs
+The core ships **abstract base components**: to show concrete widgets you use a Tuain UI package (e.g. `tuain-ng-forms-ant` / `tuain-ng-forms-ionic`) or your own components that **extend** `FieldComponent`, `ActionComponent`, `LibTableComponent`, etc. and supply their template. In the form template you bind each component to its model object:
 
-This component allows to receive the following information
+```html
+<lib-form-header [form]="form" (goBackEvent)="goBack()"></lib-form-header>
 
-| Input Name | Description |
-| --- | ----------- |
-| fieldCode | |
-| fieldType | |
-| recordData | |
+<app-field   *ngFor="let f of getFields()"  [field]="f"></app-field>
+<app-action  *ngFor="let a of getHeaderActions()" [action]="a"></app-action>
+<app-table   *ngFor="let t of getTables()"  [table]="t"></app-table>
+```
 
-#### LibTableComponent
+> Until the UI packages are available, the app defines its own field/action/table components by extending this library's base components and overriding `start()`/`focus()` and the template.
 
-##### Inputs
+---
 
-This component allows to receive the following information
+## Public API
 
-| Input Name | Description |
-| --- | ----------- |
-| table | |
-| tableRecords | |
-| currentMode | |
-| waiting | |
+Exported (from `tuain-ng-forms-lib`):
 
-##### Outputs
-
-This component allows to generate the following events to his container
-
-| Output Event | Description |
-| --- | ----------- |
-| tableActionActivated | |
-| tableStartGetData | |
-
-#### BasicFormComponent
-
-##### Methods
-
-This component is provides as the base class to define any form in the Angular application as a super-class
-to provide all basic form operation with a full set of methods to allow make any objects access and
-modifications.
-
-##### General form operation methods
-
-This set of methods are oriented to access and modify general form attributes and configuration.
-
-| Method Name | Description |
-| --- | ----------- |
-| `supportState` | Informs if a form supports the operation on a particular state |
-| `supportMode`<br>*deprecated* | Informs if a form supports the operation on a particular state|
-| `getTitle` | Returns de form title |
-| `cleanData` | Cleand all fields and tables |
-| `displayActionServerError` | Show the error after the execution of the backend portion of an action|
-| `displayValidationServerError` | Show the error after the execution of the backend portion of a field validation |
-| `showModalDialog` | Shows a customized modal dialog|
-| `openUploadDialog` | Shows a standar file upload modal dialog|
-| `goBackForm` | Change the route of the application to go back to previous form|
-| `goToSubPage` | Request a new route to be displayed |
-| `setError` | Define the global form error|
-| `get formManager` | Returns the object that supports the data and structure of the form|
-| `resetError` | Clear the global error form object|
-| `getErrorType` | Returns the global form error type |
-| `getErrorMessage`<br>*deprecated* | Returns the global form error message |
-| `getErrorDetail`<br>*deprecated* | Returns the global form error detail |
-| `getErrorCode` | | Returns the global form error code |
-| `get errorMessage` | Returns the global form error message |
-| `get errorDetail` | Returns the global form error detail |
-| `getCurrentState` | Return the current state |
-| `getCurrentMode`<br>*deprecated* | Return the current state |
-| `getSubject` | Return the subject id of the form |
-| `getformSubject`<br>*deprecated* | Return the subject id of the form |
-| `errorOccured`| Return if there is an error |
-| `changeState` | Modify the current state |
-
-###### Fields related methods
-
-This set of methods allow subclass to access and modify fields in the form.
-
-| Method Name | Description |
-| --- | ----------- |
-| `getFields` | Returns the form fields |
-| `getField` | Returns a form field object based on its name|
-| `enableField` | Set an status attribute of the field in order to be editable|
-| `disableField` | Set an status attribute of the field in order prevent edition |
-| `getFieldValue` | Returns the value of a field |
-| `getFieldOptions` | Returns an array with all posible values of the field with a description text|
-| `setFieldValue` | Change the current value of a field |
-| `setFieldErrorMessage` | Defines an error message for a field |
-| `setFieldOptions` | Define the posible values of the field with an array of values and description text |
-| `setFieldRequired` | Change an status attribute of the field to determine if it is required |
-| `applyProcessToFieldSet` | Execute a process on all the fields specified in an array, section or sub-section. If the fields are not specified, the execition will be over the whole set of fields in the form `(processFunc, fieldArray?, sectionCode?, subSectionCode?)`|
-| `cleanFields` | Clean all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `getRequiredFields` | Obtain all the required fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `getRequiredEmptyFields` | Obtain all the required and empty fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `getChangedFields` | Obtain all the fields that changed since the last backend refresh over a field set specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `getFieldsWithValidationIssues` | Obtain all the fields that has validation errors over a field set specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `tagFieldsWithError` | Set an error mesagge for all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(errorMessage, fieldArray?, sectionCode?, subSectionCode?)`|
-| `cleanErrorFields` | Clean the error on all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `showLabelFields` | Show the label on all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `hideLabelFields` | Hide the label on all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `enableFields` | Enable for edition all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `disableFields` | Disable for edition all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `showFields` | Show all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `hideFields` | Hide all the fields specified in an array, section or sub-section using their default value. If the fields are not specified, the execition will be over the whole set of fields in the form `(fieldArray?, sectionCode?, subSectionCode?)`|
-| `showFieldInfo` | Show help information related with a field |
-| `addFieldInputValidation` | `(fields, callbackMethod)`|
-| `addFieldValidationStart` | Defines a callback function to be triggered when a field change its content in order to be validated. The returned value of this callback defines if the process must continue in the backend|
-| `addFieldValidationFinish` | Defines a callback function to be triggered when the field validation process returns from the backend portion execution in order to be completed |
-| `startFieldInputValidation` | Defines a callback function to be triggered when a field receive any input and is change is not complete, so the user typing can be verified and validated. This process do not have any backend process by default
-| `startFieldValidation` | Start the field validation process|
-| `startServerFieldValidation` | Trigger the execution of a field validation, starting on the backend portion without the first callbacks execution|
-
-###### Actions related methods
-
-This set of methods allow subclass to access and modify actions in the form.
-
-| Method Name | Description |
-| --- | ----------- |
-| `getHeaderActions` | Returns the form actions defined to be placed on the form header|
-| `getAction` | Returns a form action object based on its name|
-| `showAction` | Change the visibility of an action to be displayed based on its name|
-| `hideAction` | Change the visibility of an action to be hidden based on its name|
-| `showActions` | Change the visibility of an action set to be displayed based on an array of names|
-| `hideActions` | Change the visibility of an action set to be hidden based on an array of names|
-| `enableAction` | Modify the status of an action to be available for execution|
-| `disableAction` | Modify the status of an action to prevent execution|
-| `enableActions` | Modify the status of an actionset  to be available for execution based on an array of names|
-| `disableActions` | Modify the status of an action to prevent execution based on an array of names|
-| `addActionMethodStart` | Defines a callback function to be triggered when an action is requested. The returned value of this callback defines if the process must continue in the backend|
-| `addActionMethodFinish` | Defines a callback function to be triggered when an action returns from the backend portion execution in order to be completed |
-| `startAction` | Start the execution of an action, starting with the initial callbacks, continuing in the backend if former callbacks were ok and execuing the after backend callbacks|
-| `startServerAction` | Trigger the execution of an action, starting on the backend portion without the first callbacks execution|
-
-###### Tables related methods
-
-This set of methods allow subclass to access and modify tables in the form.
-
-| Method Name | Description |
-| --- | ----------- |
-| `getTables` |  Returns all form tables |
-| `getTable` | Returns a form table object based on its name |
-| `showTable` | Change the visibility of a table to be displayed based on its name |
-| `hideTable` | Change the visibility of a table to be hidden based on its name|
-| `showTables` | Change the visibility of a table set to be displayed based on an array of names|
-| `hideTables` | Change the visibility of a table set to be hidden based on an array of names|
-| `cleanTable` | Delete the content of a table |
-| `getTableRecord` | Returns an `array` with all records of a table|
-| `displayTableServerError` | Shows an error message with the result of a table action on the backend|
-| `addTableActionStart` | Defines a callback function to be triggered when an action of the table is requested. The returned value of this callback defines if the process must continue in the backend|
-| `addTableActionFinish` | Defines a callback function to be triggered when an action of the table returns from the backend portion execution in order to be completed |
-| `addTableGetDataStart` | Defines a callback function to be triggered when the table need to refresh or update its data as a consequence of pagination or any refresh request|
-| `addTableGetDataFinish` | Defines a callback function to be triggered when the table data refresh or update is executed on the backend|
-| `startTableAction` | Start the execution of a table action, starting with the callback actions, continue in the backend if former callbacks were ok and execute the after backend callbacks|
-| `startTableServerAction` | Trigger the execution of a table action, starting on the backend portion without the first callbacks execution|
-| `startTableGetData` | Start the execution of a table get data action, starting with the callback actions, continue in the backend if former callbacks were ok and execute the after backend callbacks|
-| `startTableServerGetData` | Trigger the execution of a table get data action, starting on the backend portion without the first callbacks execution|
-
-###### Sections related methods
-
-This set of methods allow subclass to access and modify fields in the form.
-
-| Method Name | Description |
-| --- | ----------- |
-| `getSections` | Returns all form sections |
-| `getSection` | Returns the section object based on its name |
-| `activateSection` | Set a section as the active one based on its name |
-| `activeSection` | Returns the name of the active section |
-| `getSubSection` | Returns the sub-ection object based on the section name and subsection name |
-| `getSectionsTitles` | Returns an array with all section titles |
-| `showSection` | Change the visibility of a section to be displayed based on its name |
-| `hideSection` | Change the visibility of a section to be hidden based on its name |
-| `showSections` | Change the visibility of a section set to be displayed based on an array of names|
-| `hideSections` | Change the visibility of a section set to be hidden based on an array of names|
-| `showSubSection` | Change the visibility of a sub-section to be displayed based on the section name and subsection name|
-| `hideSubSection` | Change the visibility of a sub-section to be hidden based on the section name and subsection name|
-| `addSectionActivation` | Defines a callback function to be triggered when any of the sections with name in the input array of section names is activated|
-| `addSectionInactivation` | Defines a callback function to be triggered when any of the sections with name in the input array of section names is inactivated|
-| `checkSectionRequiredFields` | Return a list of a section based on its name, with the required fields that are empty |
-| `validateSectionConsistency` | Verify that all required fields have value and don't have any validation errors |
-
-###### Utilities and complex methods
-
-This set of methods interact with multiple element types to provide tools to simplify complex
-but common operations in the forms.
-
-| Method Name | Description |
-| --- | ----------- |
-| `copyTableRecordToFields` | Copy all columns in a table record to a set of fields using a mapping objec to relate column names with field names. If the mapping object is not present, look for fields with same names|
-| `defineEditionTable` | Configure an object to copy fields, enable edition, hide fields and actions to operate table and fields for records edition|
+- **Model:** `FormStructureAndData`, `FieldDescriptor`, `FormAction`, `RecordTable`, `RecordTableColumn`, `TableAction`, `TableRecordData`, `RecordFormSection`, `RecordFormSubSection`, and the bases `FormPiece`/`FormPiecePropagate`/`FormElement`.
+- **Contracts:** `IForm`, `IField`, `IAction`, `ITable`, `ITableColumn`, `ITableAction`, `ITableRecord`, `ISection`, `ISubSection`, `IFormPiece`/`IFormElement`, `IFormConfig` and the definition/event types.
+- **Base components (standalone):** `BasicFormComponent`, `FieldComponent`, `ActionComponent`, `LibTableComponent`, `LibTableRecordFieldComponent`, `LibTableRecordActionComponent`, `SectionComponent`, `SubSectionComponent`, `FormHeaderComponent`, `FormErrorComponent`, `ElementComponent`, `PieceComponent`.
+- **Services and tokens:** `LibFormManagerService`, `LibEventManagerService`, `LibFileManagementService`, `BaseIconResolverService` + `ICON_RESOLVER`, `SseLiveConnectionService` + `SSE_LIVE_CONNECTION_CONFIG`.
 
 ## License