tuain-ng-forms-lib 17.2.20 → 17.2.22

package/src/lib/services/event-manager.service.ts

@@ -0,0 +1,45 @@
+import { Subject, BehaviorSubject, ReplaySubject } from 'rxjs';
+
+export class LibEventManagerService {
+  eventSubjects: any = {};
+  eventSubjectParams: any = {};
+
+  constructor(eventSet: any[]) {
+    eventSet.forEach((event) => { this.addEventName(event); });
+  }
+
+  addEventName(event: any, rebuild = false) {
+    const eventObject = (typeof event === 'string') ? { name: event } : event;
+    const { name, type, initialValue, windowTime, timestampProvider } = eventObject;
+    const currentSubject = this.eventSubjects[name];
+    if (rebuild || !currentSubject) {
+      if (type === 'behaviour') {
+        const newEventSubject: BehaviorSubject<any> = new BehaviorSubject(initialValue);
+        this.eventSubjects[name] = newEventSubject;
+      } else if (type === 'subject') {
+        const newEventSubject: Subject<any> = new Subject();
+        this.eventSubjects[name] = newEventSubject;
+      } else {
+        const newEventSubject: ReplaySubject<any> = new ReplaySubject(initialValue, windowTime, timestampProvider);
+        this.eventSubjects[name] = newEventSubject;
+      }
+      this.eventSubjectParams[name] = { name: name, windowTime, timestampProvider };
+    }
+  }
+
+  resetSubject(eventClassName) {
+    const { name, windowTime, timestampProvider } = this.eventSubjectParams[eventClassName];
+    return this.addEventName({ name, windowTime, timestampProvider });
+  }
+
+  getEventNames() { return Object.keys(this.eventSubjects); }
+  getSubject(eventClassName) { return eventClassName ? this.eventSubjects[eventClassName] : null; }
+  subscribe(eventClassName, callback) { return this.getSubject(eventClassName).subscribe(callback); }
+  next(eventClassName, data) {
+    const subject = this.getSubject(eventClassName);
+    if (!subject) {
+      console.log(`No se encontró subject ${eventClassName}`);
+    }
+    subject.next(data);
+  }
+}

package/src/lib/services/file-manager.service.ts

@@ -0,0 +1,7 @@
+export class LibFileManagementService {
+  openFile(fileBase64Data, fileName, fileType) { }
+  saveFileFromURL(fileUrl, fileName = null, fileType = null) { }
+  saveFile(fileBase64Data, fileName, fileType) { }
+  printPdfFile(pdfBufferData) { }
+}
+

package/src/lib/services/form-manager.service.ts

@@ -0,0 +1,89 @@
+import { nanoid } from 'nanoid';
+
+export class LibFormManagerService {
+  pageStack: any[];
+
+  constructor() {
+    this.cleanStack();
+  }
+
+  // Métodos virtuales para las aplicaciones
+  getFormDefinition(formCode) { }
+  execServerAction(actionDetail) { }
+  goToForm(formCode, token, subject) { }
+  async loadStack() { }
+  saveStack() { }
+
+  cleanStack() { this.pageStack = []; }
+  resetPageStack() { this.cleanStack() }
+
+  findFormInStack(token) {
+    const index = this.pageStack.findIndex(item => item?.token === token);
+    const data = (index >= 0) ? this.pageStack[index] : null;
+    return { index, data };
+  }
+
+  replaceItem(token, formInfo) {
+    if (!token || !formInfo) { return; }
+    const { index, data: storedForm } = this.findFormInStack(token);
+    let updatedForm: any = null;
+    if (index >= 0) {
+      updatedForm = { ...storedForm };
+      updatedForm.subject = formInfo?.subject ?? storedForm.subject;
+      updatedForm.state = formInfo?.state ?? storedForm.state;
+      updatedForm.fields = storedForm?.fields ?? {};
+      updatedForm.extra = storedForm?.extra ?? {};
+      if (formInfo.fields) {
+        Object.assign(updatedForm.fields, formInfo.fields);
+      }
+      if (formInfo.extra) {
+        Object.assign(updatedForm.extra, formInfo.extra);
+      }
+      this.pageStack[index] = updatedForm;
+      this.saveStack();
+    }
+  }
+
+  stack(origin, target) {
+    const token = nanoid(6);
+    this.replaceItem(target.originToken, origin);
+    this.pageStack.push({ token, ...target });
+    this.saveStack();
+    return token;
+  }
+
+  unstack(token = null) {
+    let index = (token) ? this.findFormInStack(token).index : this.pageStack.length - 2;
+    let formInfo = null;
+    if (index >= 0) {
+      formInfo = this.pageStack[index];
+      this.pageStack.splice(index + 1);
+      this.saveStack();
+    }
+    return formInfo;
+  }
+
+  getFormInfo(token: string) {
+    const { data } = this.findFormInStack(token);
+    return {
+      token: data?.token,
+      subject: data?.subject,
+      state: data?.state,
+      originToken: data?.originToken,
+      fields: data?.fields ?? {},
+      extra: data?.extra ?? {}
+    };
+  }
+
+  openForm(origin: any, target: any) {
+    (!origin) && this.cleanStack();
+    target.originToken = origin?.token ?? null;
+    const token = this.stack(origin, target);
+    this.goToForm(target.name, token, target.subject);
+  }
+
+  backTo(targetToken = null) {
+    const formInfo: any = this.unstack(targetToken);
+    formInfo && formInfo.name && this.goToForm(formInfo.name, formInfo.token, formInfo.subject);
+  }
+}

package/src/lib/services/icon-dictionary.service.ts

@@ -0,0 +1,159 @@
+export const iconDictionary = {
+  SELECT: 'icmn-pushpin',
+  selectHolder: 'icmn-user-check',
+  validateAML: 'icmn-warning',
+  NEW: 'icmn-file-empty',
+  'FORM-CREATE': 'icmn-file-empty',
+  'FORM-EDIT': 'icmn-pencil2',
+  'FORM-VIEW': 'icmn-file-text2',
+  SHIELD: 'fa fa-shield',
+  LOGIN: 'fa fa-sign-in',
+  LOGOUT: 'fa fa-sign-out',
+  VIEW: 'icmn-eye',
+  EDIT: 'icmn-pencil',
+  DETAIL: 'icmn-binoculars',
+  DELETE: 'icmn-bin',
+  SERVERPROCESS: 'icmn-cloud-check',
+  DEFAULT: 'icmn-home',
+  HOME: 'icmn-home',
+  IMAGE: 'icmn-image',
+  PICTURE: 'icmn-camera',
+  TEXT: 'icmn-file-text',
+  MOVEUP: 'icmn-arrow-up',
+  MOVEDOWN: 'icmn-arrow-down',
+  NEWAFFILIATION: 'icmn-profile',
+  AUTONEWAFFILIATION: 'icmn-profile',
+  PROFILE: 'icmn-profile',
+  ZIPFILE: 'icmn-file-zip',
+  COPY: 'icmn-copy',
+  FOLDER: 'icmn-folder-open',
+  TAGS: 'icmn-price-tags',
+  BARCODE: 'icmn-barcode',
+  BARCODE2: 'fa fa-barcode',
+  KEYBOARD: 'fa fa-keyboard-o',
+  CART: 'icmn-cart',
+  CAMARACOMERCIO: 'icmn-book',
+  SARLAFT: 'icmn-binoculars',
+  SCREENING: 'icmn-user-check',
+  ENTITY: 'icmn-library',
+  COIN: 'icmn-coin-dollar',
+  CREDITCARD: 'icmn-credit-card',
+  CONTACTS: 'icmn-address-book',
+  LOCATION: 'icmn-location',
+  CODES: 'icmn-file-text',
+  BPMCODES: 'icmn-file-text2',
+  MAIL: 'icmn-envelop',
+  MAP: 'icmn-map',
+  WARNING: 'icmn-warning',
+  NOTIFICATION: 'icmn-notification',
+  QUESTION: 'icmn-question',
+  INFO: 'icmn-info',
+  SAVE: 'icmn-floppy-disk',
+  INBOXFULL: 'icmn-drawer',
+  INBOXEMPTY: 'icmn-drawer2',
+  DATABASE: 'icmn-database',
+  UNDO: 'icmn-undo2',
+  REDO: 'icmn-redo2',
+  CHAT: 'icmn-bubbles4',
+  BRIEFCASE: 'icmn-briefcase',
+  USER: 'icmn-user',
+  ADDUSER: 'icmn-user-plus',
+  REMOVEUSER: 'icmn-user-minus',
+  SPINNER: 'icmn-spiiner3',
+  SEARCH: 'icmn-search',
+  ZOOMIN: 'icmn-zoom-in',
+  ZOOMOUT: 'icmn-zoom-out',
+  KEY: 'icmn-key',
+  LOCK: 'icmn-lock',
+  lockDoc: 'icmn-lock',
+  UNLOCK: 'icmn-unlocked',
+  CONFIG: 'icmn-wrench',
+  TUNE: 'icmn-equalizer',
+  GEAR: 'icmn-cog',
+  ADMIN: 'fa fa-cogs',
+  LIST: 'icmn-list',
+  FORMRECORD: 'icmn-insert-template',
+  PIE: 'icmn-pie-chart',
+  GRAPH: 'icmn-stats-dots',
+  TROPHY: 'icmn-trophy',
+  GIFT: 'icmn-gift',
+  GAUGE: 'icmn-meter',
+  FIRE: 'icmn-fire',
+  LAB: 'icmn-lab',
+  DELIVER: 'icmn-truck',
+  MOBILE: 'icmn-mobile',
+  MOBILE2: 'icmn-mobile',
+  RECHARGE: 'icmn-power-cord',
+  TREE: 'icmn-tree',
+  EARTH: 'icmn-earth',
+  TARGET: 'icmn-target',
+  POWER: 'icmn-switch',
+  VERIFY: 'icmn-clipboard',
+  UPLOAD: 'icmn-cloud-upload',
+  DOWNLOAD: 'icmn-cloud-download',
+  DOWNLOADSET: 'icmn-cloud-download',
+  LINK: 'icmn-link',
+  ATACH: 'icmn-atachment',
+  EYE: 'icmn-eye',
+  NOEYE: 'icmn-eye-blocked',
+  BOOKMARK: 'icmn-bookmark',
+  STAR: 'icmn-star-full',
+  HEART: 'icmn-heart',
+  HEARTBROKEN: 'icmn-heart-broken',
+  HAPPY: 'icmn-happy',
+  SAD: 'icmn-sad',
+  ACTIVATE: 'icmn-checkmark',
+  INACTIVATE: 'icmn-cross',
+  APPROVE: 'icmn-checkmark',
+  REJECT: 'icmn-cross',
+  CANCEL: 'icmn-cross',
+  CLOSE: 'icmn-ungroup',
+  CLEAN: 'fa fa-eraser',
+  CHECK: 'icmn-checkmark',
+  UNCHECK: 'icmn-cross',
+  SELECTROW: 'icmn-checkbox-unchecked',
+  UNSELECTROW: 'icmn-checkbox-checked',
+  CHECKED: 'icmn-checkbox-checked',
+  UNCHECKED: 'icmn-checkbox-unchecked',
+  ENTER: 'icmn-enter',
+  EXIT: 'icmn-exit',
+  CUT: 'icmn-scissors',
+  FILTER: 'icmn-filter',
+  PLAY: 'icmn-play2',
+  STOP: 'icmn-stop',
+  UP: 'icmn-circle-up',
+  DOWN: 'icmn-circle-down',
+  RIGHT: 'icmn-circle-right',
+  LEFT: 'icmn-circle-left',
+  SORTASC: 'icmn-sort-alpha-asc',
+  SORTDSC: 'icmn-sort-alpha-desc',
+  TABLE: 'icmn-table',
+  OFFICE: 'icmn-office',
+  SHARE: 'icmn-share',
+  FACEBOOK: 'icmn-facebook',
+  WHATSAPP: 'icmn-whatsapp',
+  TWITTER: 'icmn-twitter',
+  YOUTUBE: 'icmn-youtube',
+  PDF: 'icmn-file-pdf',
+  EXCEL: 'icmn-file-excel',
+  HOLDER: 'icmn-profile',
+  XXX: 'fa fa-first-order',
+  BANK: 'fa fa-bank',
+  CREDITCARD2: 'fa fa-credit-card-alt',
+  BUS: 'fa fa-bus',
+  TELEVISION: 'icmn-tv',
+  BACK: 'fa fa-arrow-left',
+  SEND: 'fa fa-paper-plane-o',
+  TEXTFILE: 'fa fa-file-text-o',
+  PERSON: 'fa fa-user',
+  BATCHFILE: 'fa fa-wpforms',
+  REQUESTS: 'icmn-stack',
+  THUMBUP: 'fa fa-thumbs-o-up',
+  THUMBDOWN: 'fa fa-thumbs-o-down',
+  EXCLAMATION: 'fa fa-exclamation-circle',
+};
+
+export class IconDictionaryService {
+  mapIcon = (iconName) => (iconName && iconDictionary[iconName])
+    ? iconDictionary[iconName] : iconDictionary.DEFAULT
+}

package/src/lib/tuain-ng-forms-lib.module.ts

@@ -0,0 +1,40 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { FormsModule } from '@angular/forms';
+
+import { BasicFormComponent } from './components/forms/basic-form';
+import { ActionComponent } from './components/elements/action.component';
+import { FieldComponent } from './components/elements/field.component';
+import { ElementComponent } from './components/elements/layout/element.component';
+import { FormErrorComponent } from './components/elements/layout/form-error.component';
+import { FormHeaderComponent } from './components/elements/layout/form-header.component';
+import { SectionComponent } from './components/elements/layout/section.component';
+import { SubSectionComponent } from './components/elements/layout/sub-section.component';
+import { LibTableRecordActionComponent } from './components/elements/tables/table-record-action.component';
+import { LibTableRecordFieldComponent } from './components/elements/tables/table-record-field.component';
+import { LibTableComponent } from './components/elements/tables/table.component';
+
+const COMPONENTS = [
+  BasicFormComponent,
+  ActionComponent,
+  FieldComponent,
+  ElementComponent,
+  FormErrorComponent,
+  FormHeaderComponent,
+  SectionComponent,
+  SubSectionComponent,
+  LibTableRecordActionComponent,
+  LibTableRecordFieldComponent,
+  LibTableComponent];
+
+@NgModule({
+  declarations: COMPONENTS,
+  imports: [
+    CommonModule,
+    RouterModule,
+    FormsModule,
+  ],
+  exports: COMPONENTS
+})
+export class TuainNgFormsLibModule { }

package/{public-api.d.ts → src/public-api.ts}

@@ -1,3 +1,7 @@
+/*
+ * Public API Surface of tuain-ng-forms-lib
+ */
+
 export * from './lib/components/elements/action.component';
 export * from './lib/components/elements/field.component';
 export * from './lib/components/elements/layout/element.component';
@@ -13,3 +17,4 @@ export * from './lib/services/event-manager.service';
 export * from './lib/services/form-manager.service';
 export * from './lib/services/file-manager.service';
 export * from './lib/tuain-ng-forms-lib.module';
+

package/src/test.ts

@@ -0,0 +1,27 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js';
+import 'zone.js/testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: {
+  context(path: string, deep?: boolean, filter?: RegExp): {
+    <T>(id: string): T;
+    keys(): string[];
+  };
+};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting(),
+);
+
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/tsconfig.lib.json

@@ -0,0 +1,15 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/tsconfig.spec.json

@@ -0,0 +1,17 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/esm2022/lib/classes/forms/action.mjs

@@ -1,106 +0,0 @@
-import { Subject } from 'rxjs';
-import { elementTypes } from './form.constants';
-import { FormElement } from './element';
-const HEADER = 'HEADER';
-const attrs = {
-    actionCode: { name: '_actionCode', propagate: 'actionCode' },
-    actionName: { name: '_actionName', propagate: 'actionName' },
-    iconName: { name: '_iconName', propagate: 'iconName' },
-    inProgress: { name: '_inProgress', propagate: 'inProgress' },
-    restrictedOnField: { name: '_restrictedOnField', propagate: 'restrictedOnField' },
-    restrictedOnOperator: { name: '_restrictedOnOperator', propagate: 'restrictedOnOperator' },
-    restrictedOnValue: { name: '_restrictedOnValue', propagate: 'restrictedOnValue' },
-};
-export class FormAction extends FormElement {
-    _actionActivated = new Subject();
-    _actionCode = '';
-    _actionName = '';
-    _iconName = '';
-    _inProgress = false;
-    _newState;
-    _backend;
-    _restrictedOnField = null;
-    _restrictedOnOperator = null;
-    _restrictedOnValue = null;
-    constructor(actionDefinition, formConfig) {
-        super(actionDefinition, formConfig);
-        this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.actions ?? [];
-        this.elementType = elementTypes.action;
-        this.setAttr(attrs.actionCode, actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '');
-        this.setAttr(attrs.actionName, actionDefinition.actionTitle);
-        this.setAttr(attrs.iconName, actionDefinition.iconName || this._actionCode);
-        this.setAttr(attrs.restrictedOnField, actionDefinition.fieldRestrictedCode?.toString() ?? null);
-        if (this._restrictedOnField) {
-            this.setAttr(attrs.restrictedOnOperator, actionDefinition.operatorRestricted || '');
-            this.setAttr(attrs.restrictedOnValue, actionDefinition.valueRestricted ?? '');
-        }
-        this._backend = actionDefinition?.serverAction ?? false;
-        this._newState = actionDefinition?.newState;
-        this.setCustomAttribute('location', actionDefinition.position || HEADER);
-    }
-    get actionCode() { return this._actionCode; }
-    get actionName() { return this._actionName; }
-    get iconName() { return this._iconName; }
-    get inProgress() { return this._inProgress; }
-    get newState() { return this._newState; }
-    get backend() { return this._backend; }
-    get restrictedOnField() { return this._restrictedOnField; }
-    get restrictedOnOperator() { return this._restrictedOnOperator; }
-    get restrictedOnValue() { return this._restrictedOnValue; }
-    set actionCode(actionCode) { this.setAttr(attrs.actionCode, actionCode); }
-    set actionName(actionName) { this.setAttr(attrs.actionName, actionName); }
-    set iconName(iconName) { this.setAttr(attrs.iconName, iconName); }
-    set inProgress(inProgress) { this.setAttr(attrs.inProgress, inProgress); }
-    set newState(newState) { this._newState, newState; }
-    set backend(backend) { this._backend, backend; }
-    set restrictedOnField(restrictedOnField) { this.setAttr(attrs.restrictedOnField, restrictedOnField); }
-    set restrictedOnOperator(restrictedOnOperator) { this.setAttr(attrs.restrictedOnOperator, restrictedOnOperator); }
-    set restrictedOnValue(restrictedOnValue) { this.setAttr(attrs.restrictedOnValue, restrictedOnValue); }
-    start() { this.inProgress = true; }
-    stop() { this.inProgress = false; }
-    connectWithParentForm(form, formChangeSubject) {
-        super.connectWithParentForm(form, formChangeSubject);
-        if (this._restrictedOnField) {
-            const relatedField = this._form.fields?.[this._restrictedOnField];
-            if (relatedField) {
-                relatedField.editionFinish
-                    .subscribe(event => this.updateRestrictedVisibility(event));
-                relatedField.editionPartial
-                    .subscribe(event => this.updateRestrictedVisibility(event));
-            }
-        }
-    }
-    updateRestrictedVisibility(event) {
-        const newVisible = this._absoluteVisible && this.viewOnState(this._formState);
-        (this._visible !== newVisible) && this.setVisibility(newVisible);
-    }
-    viewOnState(state) {
-        const actionVisible = (this.visibleStates && state) ? this.visibleStates.includes(state) : false;
-        if (actionVisible && this._form && this._restrictedOnField) {
-            const relatedField = this._form.fields?.[this._restrictedOnField];
-            if (relatedField) {
-                const fieldValue = relatedField.value;
-                if ((this._restrictedOnOperator === '==' && fieldValue !== this._restrictedOnValue)
-                    || (this._restrictedOnOperator === '!=' && fieldValue === this._restrictedOnValue)) {
-                    return false;
-                }
-            }
-        }
-        return actionVisible;
-    }
-    get actionActivated() { return this._actionActivated.asObservable(); }
-    notifyActivation() { this._actionActivated.next(this._actionCode); }
-    updateFromServer(receivedAction) {
-        for (const propertyName in receivedAction) {
-            if (propertyName !== 'actionCode' && propertyName !== 'actionId') {
-                try {
-                    this[propertyName] = receivedAction[propertyName];
-                }
-                catch (e) {
-                    console.log(`Error actualizando la propiedad ${propertyName} de la acción ${this.actionCode}. ${e}`);
-                }
-            }
-        }
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"action.js","sourceRoot":"","sources":["../../../../../../projects/tuain-ng-forms-lib/src/lib/classes/forms/action.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from 'rxjs';\nimport { elementTypes } from './form.constants';\nimport { FormElement } from './element';\n\nconst HEADER = 'HEADER';\n\nconst attrs = {\n  actionCode: { name: '_actionCode', propagate: 'actionCode' },\n  actionName: { name: '_actionName', propagate: 'actionName' },\n  iconName: { name: '_iconName', propagate: 'iconName' },\n  inProgress: { name: '_inProgress', propagate: 'inProgress' },\n  restrictedOnField: { name: '_restrictedOnField', propagate: 'restrictedOnField' },\n  restrictedOnOperator: { name: '_restrictedOnOperator', propagate: 'restrictedOnOperator' },\n  restrictedOnValue: { name: '_restrictedOnValue', propagate: 'restrictedOnValue' },\n}\n\nexport class FormAction extends FormElement {\n  private readonly _actionActivated = new Subject<string>();\n  private _actionCode: string = '';\n  private _actionName: string = '';\n  private _iconName: string = '';\n  private _inProgress = false;\n  private _newState: string;\n  private _backend: boolean;\n  private _restrictedOnField: string | null = null;\n  private _restrictedOnOperator: string | null = null;\n  private _restrictedOnValue: string | null = null;\n\n  constructor(actionDefinition, formConfig) {\n    super(actionDefinition, formConfig);\n    this.propagationCustomAttributes = this._formConfig?.propagationCustomAttributes?.actions ?? [];\n    this.elementType = elementTypes.action;\n    this.setAttr(attrs.actionCode, actionDefinition.actionCode ? actionDefinition.actionCode.toString() : '');\n    this.setAttr(attrs.actionName, actionDefinition.actionTitle);\n    this.setAttr(attrs.iconName, actionDefinition.iconName || this._actionCode);\n    this.setAttr(attrs.restrictedOnField, actionDefinition.fieldRestrictedCode?.toString() ?? null);\n    if (this._restrictedOnField) {\n      this.setAttr(attrs.restrictedOnOperator, actionDefinition.operatorRestricted || '');\n      this.setAttr(attrs.restrictedOnValue, actionDefinition.valueRestricted ?? '');\n    }\n    this._backend = actionDefinition?.serverAction ?? false;\n    this._newState = actionDefinition?.newState;\n    this.setCustomAttribute('location', actionDefinition.position || HEADER);\n  }\n\n  get actionCode() { return this._actionCode; }\n  get actionName() { return this._actionName; }\n  get iconName() { return this._iconName; }\n  get inProgress() { return this._inProgress; }\n  get newState() { return this._newState; }\n  get backend() { return this._backend; }\n  get restrictedOnField() { return this._restrictedOnField; }\n  get restrictedOnOperator() { return this._restrictedOnOperator; }\n  get restrictedOnValue() { return this._restrictedOnValue; }\n\n  set actionCode(actionCode) { this.setAttr(attrs.actionCode, actionCode); }\n  set actionName(actionName) { this.setAttr(attrs.actionName, actionName); }\n  set iconName(iconName) { this.setAttr(attrs.iconName, iconName); }\n  set inProgress(inProgress) { this.setAttr(attrs.inProgress, inProgress); }\n  set newState(newState) { this._newState, newState; }\n  set backend(backend) { this._backend, backend; }\n  set restrictedOnField(restrictedOnField) { this.setAttr(attrs.restrictedOnField, restrictedOnField); }\n  set restrictedOnOperator(restrictedOnOperator) { this.setAttr(attrs.restrictedOnOperator, restrictedOnOperator); }\n  set restrictedOnValue(restrictedOnValue) { this.setAttr(attrs.restrictedOnValue, restrictedOnValue); }\n\n  start() { this.inProgress = true; }\n  stop() { this.inProgress = false; }\n\n  override connectWithParentForm(form, formChangeSubject) {\n    super.connectWithParentForm(form, formChangeSubject);\n    if (this._restrictedOnField) {\n      const relatedField = this._form.fields?.[this._restrictedOnField];\n      if (relatedField) {\n        relatedField.editionFinish\n          .subscribe(event => this.updateRestrictedVisibility(event));\n        relatedField.editionPartial\n          .subscribe(event => this.updateRestrictedVisibility(event));\n      }\n    }\n  }\n\n  updateRestrictedVisibility(event) {\n    const newVisible = this._absoluteVisible && this.viewOnState(this._formState);\n    (this._visible !== newVisible) && this.setVisibility(newVisible);\n  }\n\n  override viewOnState(state: string): boolean {\n    const actionVisible = (this.visibleStates && state) ? this.visibleStates.includes(state) : false;\n    if (actionVisible && this._form && this._restrictedOnField) {\n      const relatedField = this._form.fields?.[this._restrictedOnField];\n      if (relatedField) {\n        const fieldValue = relatedField.value;\n        if ((this._restrictedOnOperator === '==' && fieldValue !== this._restrictedOnValue)\n          || (this._restrictedOnOperator === '!=' && fieldValue === this._restrictedOnValue)) {\n          return false;\n        }\n      }\n    }\n    return actionVisible;\n  }\n\n  get actionActivated() { return this._actionActivated.asObservable(); }\n\n  notifyActivation() { this._actionActivated.next(this._actionCode); }\n\n  updateFromServer(receivedAction) {\n    for (const propertyName in receivedAction) {\n      if (propertyName !== 'actionCode' && propertyName !== 'actionId') {\n        try {\n          this[propertyName] = receivedAction[propertyName];\n        } catch (e) {\n          console.log(`Error actualizando la propiedad ${propertyName} de la acción ${this.actionCode}. ${e}`);\n        }\n      }\n    }\n  }\n}\n"]}

package/esm2022/lib/classes/forms/element.mjs

@@ -1,25 +0,0 @@
-import { FormPiecePropagate } from './piece-propagate';
-import { elementTypes } from './form.constants';
-export class FormElement extends FormPiecePropagate {
-    elementType = null;
-    constructor(elementDefinition, formConfig) {
-        super(elementDefinition, formConfig);
-    }
-    setAttr(attr, value) {
-        const { name: attrName, propagate: name } = attr;
-        try {
-            const currentValue = this[attrName];
-            if (currentValue !== value) {
-                this[attrName] = value;
-                name && this.propagateAttribute(name, value);
-            }
-        }
-        catch (e) {
-            console.log(`Atributo ${attrName} no presente o valor ${value} inconsistente. ${e}`);
-        }
-    }
-    isField() { return this.elementType === elementTypes.field; }
-    isAction() { return this.elementType === elementTypes.action; }
-    isTable() { return this.elementType === elementTypes.table; }
-}
-//# sourceMappingURL=data:application/json;base64,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