@wemake4u/form-player-se 1.0.0

package/esm2022/lib/directives/dropdown.directive.mjs

@@ -0,0 +1,233 @@
+import { Directive, Host } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-sirio-lib";
+export class DropdownDirective {
+    el;
+    renderer;
+    sirioSelect;
+    constructor(el, renderer, sirioSelect) {
+        this.el = el;
+        this.renderer = renderer;
+        this.sirioSelect = sirioSelect;
+    }
+    ngAfterViewInit() {
+        this.handleNullValue();
+        this.handleSearchable();
+    }
+    handleNullValue() {
+        if (this.sirioSelect
+            && this.sirioSelect.value === null
+            && Array.isArray(this.sirioSelect.options)) {
+            const nullOption = this.sirioSelect.options.find(option => option.value === null);
+            if (nullOption) {
+                nullOption.isSelected = true;
+            }
+        }
+    }
+    handleSearchable() {
+        const searchable = this.el.nativeElement.querySelector('.searchable');
+        if (searchable) {
+            const dropDown = this.el.nativeElement.querySelector('.sirio-dropdown');
+            const dropMenu = dropDown.querySelector('.sirio-dropdown-menu');
+            const input = searchable.querySelector('input');
+            this.renderer.insertBefore(dropDown, searchable, dropMenu);
+            this.renderer.listen(input, 'blur', (event) => {
+                this.sirioSelect.panel.close();
+            });
+            this.renderer.listen(input, 'keyup', (event) => {
+                this.onKeyUp(event, input);
+            });
+            this.renderer.listen(input, 'keydown', (event) => {
+                this.onKeyDown(event);
+            });
+            this.sirioSelect.panel.panelOpened.subscribe(() => {
+                this.activate(searchable);
+            });
+            this.sirioSelect.panel.panelClosed.subscribe(() => {
+                this.deactivate(searchable);
+            });
+        }
+    }
+    deactivate(element) {
+        this.renderer.setStyle(element, 'display', 'none');
+    }
+    activate(element) {
+        let currentValue = "";
+        if (this.sirioSelect.optionsSelected.length > 0) {
+            currentValue = this.sirioSelect.optionsSelected[0].text;
+        }
+        const input = element.querySelector("input");
+        if (!input)
+            return;
+        input.value = currentValue;
+        const dropMenu = this.el.nativeElement.querySelector('.sirio-dropdown-menu');
+        this.sirioSelect.options.forEach((option) => {
+            this.show(option, true);
+            if (currentValue == option.text) {
+                dropMenu.scrollTop = this.native(option).offsetTop;
+            }
+        });
+        this.renderer.setStyle(element, 'display', 'inline-block');
+        setTimeout(() => {
+            input.setSelectionRange(input.value.length, input.value.length);
+            input.focus();
+        });
+    }
+    onKeyUp(event, input) {
+        const { code } = event;
+        switch (code) {
+            case 'Enter':
+            case 'Space':
+            case 'ArrowDown':
+            case 'ArrowUp':
+            case 'Escape':
+                return;
+        }
+        const value = this.comparable(input.value);
+        let firstMatch = true;
+        this.sirioSelect.options.forEach((option, index) => {
+            const match = this.comparable(option.text).includes(value);
+            this.show(option, match);
+            if (match && firstMatch) {
+                option.setFocus();
+                firstMatch = false;
+            }
+            else {
+                option.removeFocus();
+            }
+        });
+    }
+    onKeyDown(event) {
+        const panel = this.sirioSelect.panel;
+        if (!panel) {
+            return;
+        }
+        const panelIsOpen = panel.panelIsOpen;
+        const { code } = event;
+        if (panelIsOpen) {
+            switch (code) {
+                case 'Enter':
+                case 'Space':
+                    if (panel.optionFocused) {
+                        panel.optionFocused?.onOptionSelected(event);
+                    }
+                    else {
+                        panel.close(event);
+                        event?.preventDefault();
+                    }
+                    break;
+                case 'ArrowDown':
+                    this.scrollDown();
+                    event?.preventDefault();
+                    break;
+                case 'ArrowUp':
+                    this.scrollUp();
+                    event?.preventDefault();
+                    break;
+                case 'Escape':
+                    panel.close(event);
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (!panelIsOpen) {
+            switch (code) {
+                case 'Enter':
+                case 'Space':
+                    panel.open(event);
+                    event?.preventDefault();
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    native(option) {
+        return option.viewContainerRef.element.nativeElement;
+    }
+    isHidden(option) {
+        return this.native(option).style.display === 'none';
+    }
+    show(option, value) {
+        this.native(option).style.display = value ? '' : 'none';
+    }
+    comparable(text) {
+        return text.toLowerCase().trim();
+    }
+    scrollDown() {
+        const panel = this.sirioSelect.panel;
+        if (!panel.optionFocused) {
+            panel.scrollBarTop();
+            panel.options.first.setFocus();
+            return;
+        }
+        const nextOptionFocused = this.findNextVisibleOption(panel.optionFocusedIndex + 1, panel.options);
+        panel.scrollBarDown();
+        panel.optionFocused?.removeFocus();
+        if (nextOptionFocused) {
+            nextOptionFocused?.setFocus();
+            return;
+        }
+        panel.scrollBarTop();
+        const firstVisible = this.findNextVisibleOption(0, panel.options);
+        if (firstVisible) {
+            firstVisible.setFocus();
+        }
+    }
+    scrollUp() {
+        const panel = this.sirioSelect.panel;
+        if (!panel.optionFocused) {
+            panel.scrollBarTop();
+            panel.options.last.setFocus();
+            return;
+        }
+        const nextOptionFocused = this.findPreviousVisibleOption(panel.optionFocusedIndex - 1, panel.options);
+        if (nextOptionFocused) {
+            panel.scrollBarUp();
+            panel.optionFocused?.removeFocus();
+            nextOptionFocused?.setFocus();
+            return;
+        }
+        panel.optionFocused?.removeFocus();
+        panel.scrollBarBottom();
+        const lastVisible = this.findPreviousVisibleOption(panel.options.length - 1, panel.options);
+        if (lastVisible) {
+            lastVisible.setFocus();
+        }
+    }
+    findPreviousVisibleOption(startIndex, options) {
+        let i = startIndex;
+        while (i >= 0) {
+            const option = options.get(i);
+            if (!this.isHidden(option)) {
+                return option;
+            }
+            i--;
+        }
+        return null;
+    }
+    findNextVisibleOption(startIndex, options) {
+        let i = startIndex;
+        while (i < options.length) {
+            const option = options.get(i);
+            if (!this.isHidden(option)) {
+                return option;
+            }
+            i++;
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DropdownDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.SirioSelectComponent, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DropdownDirective, isStandalone: true, selector: "[dropdown]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DropdownDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dropdown]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.SirioSelectComponent, decorators: [{
+                    type: Host
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dropdown.directive.js","sourceRoot":"","sources":["../../../../../projects/ngx-sirio/src/lib/directives/dropdown.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, AfterViewInit, ElementRef, Host, Renderer2 } from '@angular/core';\r\nimport { SirioSelectComponent } from 'ngx-sirio-lib';\r\n\r\n@Directive({\r\n  selector: '[dropdown]',\r\n  standalone: true\r\n})\r\nexport class DropdownDirective implements AfterViewInit {\r\n\r\n  constructor(\r\n    private el: ElementRef,\r\n    private renderer: Renderer2,\r\n    \r\n    @Host() private sirioSelect: SirioSelectComponent\r\n  ) { }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.handleNullValue();\r\n    this.handleSearchable();\r\n  }\r\n\r\n  private handleNullValue(): void {\r\n    if (this.sirioSelect\r\n      && this.sirioSelect.value === null\r\n      && Array.isArray(this.sirioSelect.options)\r\n    ) {\r\n      const nullOption = this.sirioSelect.options.find(option => option.value === null);\r\n\r\n      if (nullOption) {\r\n        nullOption.isSelected = true;\r\n      }\r\n    }\r\n  }\r\n\r\n  private handleSearchable(): void {\r\n\r\n    const searchable = this.el.nativeElement.querySelector('.searchable');\r\n    if (searchable) {\r\n      const dropDown = this.el.nativeElement.querySelector('.sirio-dropdown');\r\n      const dropMenu = dropDown.querySelector('.sirio-dropdown-menu');\r\n      const input = searchable.querySelector('input');\r\n      this.renderer.insertBefore(dropDown, searchable, dropMenu);\r\n\r\n      this.renderer.listen(input, 'blur', (event: KeyboardEvent) => {\r\n        this.sirioSelect.panel.close();\r\n      });\r\n\r\n      this.renderer.listen(input, 'keyup', (event: KeyboardEvent) => {\r\n        this.onKeyUp(event, input);        \r\n      });\r\n\r\n      this.renderer.listen(input, 'keydown', (event: KeyboardEvent) => {\r\n        this.onKeyDown(event);\r\n      });\r\n\r\n      this.sirioSelect.panel.panelOpened.subscribe(() => {\r\n        this.activate(searchable);\r\n      });\r\n\r\n      this.sirioSelect.panel.panelClosed.subscribe(() => {\r\n        this.deactivate(searchable);\r\n      });\r\n\r\n    }    \r\n  }\r\n\r\n  private deactivate(element: HTMLElement): void {\r\n    this.renderer.setStyle(element, 'display', 'none');\r\n  }\r\n\r\n  private activate(element: HTMLElement): void {\r\n    let currentValue = \"\";\r\n\r\n    if (this.sirioSelect.optionsSelected.length > 0) {\r\n      currentValue = this.sirioSelect.optionsSelected[0].text\r\n    }\r\n\r\n    const input = element.querySelector(\"input\");\r\n\r\n    if (!input)\r\n      return;\r\n\r\n    input.value = currentValue;\r\n\r\n    const dropMenu = this.el.nativeElement.querySelector('.sirio-dropdown-menu');\r\n\r\n    this.sirioSelect.options.forEach((option) => {\r\n      this.show(option, true);\r\n      if (currentValue == option.text) {\r\n        dropMenu.scrollTop = this.native(option).offsetTop;\r\n      }      \r\n    });\r\n\r\n    this.renderer.setStyle(element, 'display', 'inline-block');\r\n\r\n    setTimeout(() => {\r\n      input.setSelectionRange(input.value.length, input.value.length);\r\n      input.focus();\r\n    });\r\n  }\r\n\r\n  private onKeyUp(event: KeyboardEvent, input: any) {\r\n    const { code } = event;\r\n\r\n    switch (code) {\r\n      case 'Enter':\r\n      case 'Space':\r\n      case 'ArrowDown':\r\n      case 'ArrowUp':\r\n      case 'Escape':\r\n        return;\r\n    }\r\n\r\n    const value = this.comparable(input.value);\r\n    let firstMatch = true;\r\n\r\n    this.sirioSelect.options.forEach((option, index) => {\r\n      const match = this.comparable(option.text).includes(value);\r\n      this.show(option, match);\r\n      if (match && firstMatch) {\r\n        option.setFocus();\r\n        firstMatch = false;\r\n      }\r\n      else {\r\n        option.removeFocus();\r\n      }\r\n    });\r\n  }\r\n\r\n  private onKeyDown(event: KeyboardEvent) {\r\n    const panel = this.sirioSelect.panel;\r\n    if (!panel) {\r\n      return;\r\n    }\r\n    const panelIsOpen = panel.panelIsOpen;\r\n    const { code } = event;\r\n    if (panelIsOpen) {\r\n      switch (code) {\r\n        case 'Enter':\r\n        case 'Space':\r\n          if (panel.optionFocused) {\r\n            panel.optionFocused?.onOptionSelected(event);\r\n          }\r\n          else {\r\n            panel.close(event);\r\n            event?.preventDefault();\r\n          }\r\n          break;\r\n        case 'ArrowDown':\r\n          this.scrollDown();\r\n          event?.preventDefault();\r\n          break;\r\n        case 'ArrowUp':\r\n          this.scrollUp();\r\n          event?.preventDefault();\r\n          break;\r\n        case 'Escape':\r\n          panel.close(event);\r\n          break;\r\n        default:\r\n          break;\r\n      }\r\n    }\r\n    if (!panelIsOpen) {\r\n      switch (code) {\r\n        case 'Enter':\r\n        case 'Space':\r\n          panel.open(event);\r\n          event?.preventDefault();\r\n          break;\r\n        default:\r\n          break;\r\n      }\r\n    }\r\n  }\r\n\r\n  private native(option: any) {\r\n    return option.viewContainerRef.element.nativeElement;\r\n  }\r\n\r\n  private isHidden(option: any) {\r\n    return this.native(option).style.display === 'none';\r\n  }\r\n\r\n  private show(option: any, value: boolean) {\r\n    this.native(option).style.display = value ? '' : 'none';\r\n  }\r\n\r\n  private comparable(text: string) {\r\n    return text.toLowerCase().trim();\r\n  }\r\n\r\n  private scrollDown() {\r\n    const panel = this.sirioSelect.panel;\r\n    if (!panel.optionFocused) {\r\n      panel.scrollBarTop();\r\n      panel.options.first.setFocus();\r\n      return;\r\n    }\r\n    const nextOptionFocused = this.findNextVisibleOption(panel.optionFocusedIndex + 1, panel.options);\r\n    panel.scrollBarDown();\r\n    panel.optionFocused?.removeFocus();\r\n    if (nextOptionFocused) {\r\n      nextOptionFocused?.setFocus();\r\n      return;\r\n    }\r\n    panel.scrollBarTop();\r\n    const firstVisible = this.findNextVisibleOption(0, panel.options);\r\n    if (firstVisible) {\r\n      firstVisible.setFocus();\r\n    }\r\n  }\r\n\r\n  private scrollUp() {\r\n    const panel = this.sirioSelect.panel;\r\n    if (!panel.optionFocused) {\r\n      panel.scrollBarTop();\r\n      panel.options.last.setFocus();\r\n      return;\r\n    }    \r\n    const nextOptionFocused = this.findPreviousVisibleOption(panel.optionFocusedIndex - 1, panel.options);\r\n    if (nextOptionFocused) {\r\n      panel.scrollBarUp();\r\n      panel.optionFocused?.removeFocus();\r\n      nextOptionFocused?.setFocus();\r\n      return;\r\n    }\r\n    panel.optionFocused?.removeFocus();\r\n    panel.scrollBarBottom();\r\n    const lastVisible = this.findPreviousVisibleOption(panel.options.length - 1, panel.options);\r\n    if (lastVisible) {\r\n      lastVisible.setFocus();\r\n    }\r\n  }\r\n\r\n  private findPreviousVisibleOption(startIndex: number, options: any): any | null {\r\n    let i = startIndex;\r\n    while (i >= 0) {\r\n      const option = options.get(i);\r\n      if (!this.isHidden(option)) {\r\n        return option;\r\n      }\r\n      i--;\r\n    }\r\n    return null;\r\n  }\r\n\r\n  private findNextVisibleOption(startIndex: number, options: any): any | null {\r\n    let i = startIndex;\r\n    while (i < options.length) {\r\n      const option = options.get(i);\r\n      if (!this.isHidden(option)) {\r\n        return option;\r\n      }\r\n      i++;\r\n    }\r\n    return null;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/directives/frame-security.directive.mjs

@@ -0,0 +1,66 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FrameSecurityDirective {
+    el;
+    renderer;
+    frameSecurity = null;
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    ngAfterViewInit() {
+        const frame = this.el.nativeElement;
+        const sandbox = this.getSandBox(this.frameSecurity);
+        if (sandbox)
+            this.renderer.setAttribute(frame, 'sandbox', sandbox);
+        const allow = this.getAllow(this.frameSecurity);
+        if (allow)
+            this.renderer.setAttribute(frame, 'allow', allow);
+    }
+    getSandBox(security) {
+        let allowedProperties = [
+            "allowScripts",
+            "allowSameOrigin",
+            "allowForms",
+            "allowModals",
+            "allowPopups",
+            "allowTopNavigation",
+            "allowStorageAccessByUserActivation"
+        ];
+        let sandBox = Object.entries(security)
+            .filter(([key, value]) => value === true && allowedProperties.includes(key))
+            .map(([key]) => this.camelToKebabCase(key))
+            .join(' ');
+        return sandBox;
+    }
+    ;
+    getAllow(security) {
+        let allowedProperties = [
+            "fullscreen",
+            "geolocation",
+            "camera",
+            "microphone"
+        ];
+        let allow = Object.entries(security)
+            .filter(([key, value]) => value === true && allowedProperties.includes(key))
+            .map(([key]) => key)
+            .join(' ');
+        return allow;
+    }
+    ;
+    camelToKebabCase(str) {
+        return str.replace(/[A-Z]/g, (match) => '-' + match.toLowerCase());
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FrameSecurityDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: FrameSecurityDirective, isStandalone: true, selector: "[frameSecurity]", inputs: { frameSecurity: "frameSecurity" }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FrameSecurityDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[frameSecurity]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { frameSecurity: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/grid.directive.mjs

@@ -0,0 +1,68 @@
+import { Directive, Input, Host } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ag-grid-angular";
+export class GridDirective {
+    grid;
+    rowSource = null;
+    constructor(grid) {
+        this.grid = grid;
+        grid.gridReady.subscribe(() => {
+            this.isGridReady = true;
+        });
+    }
+    ngOnChanges(changes) {
+        if (changes["rowSource"]) {
+            this.onRowChanges();
+        }
+    }
+    isGridReady = false;
+    onRowChanges() {
+        if (this.isArray(this.rowSource)) {
+            this.setRowData(this.rowSource);
+        }
+        else if (this.isDataSource(this.rowSource)) {
+            this.setDataSource(this.rowSource);
+        }
+        else {
+            this.setRowData([]);
+        }
+    }
+    setRowData(rowSource) {
+        this.grid.rowModelType = 'clientSide';
+        if (this.isGridReady) {
+            this.grid.api.setGridOption('rowData', rowSource);
+        }
+        else {
+            this.grid.rowData = rowSource;
+        }
+    }
+    setDataSource(rowSource) {
+        this.grid.rowModelType = 'infinite';
+        if (this.isGridReady) {
+            this.grid.api.setGridOption('datasource', rowSource);
+        }
+        else {
+            this.grid.datasource = rowSource;
+        }
+    }
+    isArray(rowSource) {
+        return Array.isArray(rowSource);
+    }
+    isDataSource(obj) {
+        return typeof obj.getRows === "function";
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GridDirective, deps: [{ token: i1.AgGridAngular, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: GridDirective, isStandalone: true, selector: "[rowSource]", inputs: { rowSource: "rowSource" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: GridDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[rowSource]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.AgGridAngular, decorators: [{
+                    type: Host
+                }] }], propDecorators: { rowSource: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/register.directive.mjs

@@ -0,0 +1,86 @@
+import { Directive, Input, ContentChild, ContentChildren } from '@angular/core';
+import { RegisterService } from '../services/register.service';
+import { createControl } from '../controls/factory';
+import { DynamicFieldsComponent } from '../dynamic-fields/dynamic-fields.component';
+import { ItemControl } from '../controls/control';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/register.service";
+import * as i2 from "../services/proxy.service";
+export class RegisterDirective {
+    el;
+    registerService;
+    proxyService;
+    register = null;
+    componentRef;
+    dynamicField;
+    itemFields;
+    constructor(el, registerService, proxyService) {
+        this.el = el;
+        this.registerService = registerService;
+        this.proxyService = proxyService;
+    }
+    ngAfterContentInit() {
+        this.registerControl();
+    }
+    ngOnDestroy() {
+        this.unregisterControl();
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    destroy$ = new Subject();
+    registerControl() {
+        const name = this.getName();
+        const register = (this.register.type === 'dynamiclist')
+            ? this.createDynamicRegister(name, this.register, this.componentRef, this.el, this.itemFields)
+            : this.dynamicField?.getRegister();
+        const control = createControl(name, this.register, this.componentRef, this.el, register);
+        this.registerService.register(name, control);
+    }
+    unregisterControl() {
+        this.registerService.unregister(this.getName());
+    }
+    getName() {
+        return this.register.name ?? this.register.id;
+    }
+    createDynamicRegister(name, metadata, componentRef, el, itemFields) {
+        const newRegister = new RegisterService(this.proxyService, null);
+        const registerAll = (itemFields) => {
+            newRegister.unregisterAll();
+            itemFields.forEach((itemField, index) => {
+                const register = itemField.getRegister();
+                const newName = `${name}-${index}`;
+                const control = new ItemControl(newName, index, metadata, componentRef, el, register);
+                newRegister.register(newName, control);
+            });
+        };
+        registerAll(itemFields);
+        itemFields.changes
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((itemFields) => {
+            registerAll(itemFields);
+        });
+        return newRegister;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RegisterDirective, deps: [{ token: i0.ElementRef }, { token: i1.RegisterService }, { token: i2.ProxyService }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: RegisterDirective, isStandalone: true, selector: "[register]", inputs: { register: "register", componentRef: "componentRef" }, queries: [{ propertyName: "dynamicField", first: true, predicate: DynamicFieldsComponent, descendants: true }, { propertyName: "itemFields", predicate: DynamicFieldsComponent, descendants: true }], ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RegisterDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[register]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.RegisterService }, { type: i2.ProxyService }], propDecorators: { register: [{
+                type: Input
+            }], componentRef: [{
+                type: Input
+            }], dynamicField: [{
+                type: ContentChild,
+                args: [DynamicFieldsComponent]
+            }], itemFields: [{
+                type: ContentChildren,
+                args: [DynamicFieldsComponent, { descendants: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/repeat.directive.mjs

@@ -0,0 +1,38 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+export class RepeatDirective {
+    controlContainer;
+    repeat = null;
+    constructor(controlContainer) {
+        this.controlContainer = controlContainer;
+    }
+    ngOnChanges(changes) {
+        if (changes["repeat"]) {
+            const formArray = this.controlContainer.control;
+            const value = changes["repeat"].currentValue;
+            if (Number.isInteger(value) && value >= 0)
+                this.resizeArray(formArray, value);
+        }
+    }
+    resizeArray(formArray, size) {
+        while (formArray.length < size) {
+            formArray.addNewItem();
+        }
+        while (formArray.length > size) {
+            formArray.removeAt(formArray.length - 1);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RepeatDirective, deps: [{ token: i1.ControlContainer }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: RepeatDirective, isStandalone: true, selector: "[repeat]", inputs: { repeat: "repeat" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: RepeatDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[repeat]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.ControlContainer }], propDecorators: { repeat: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/directives/tab.directive.mjs

@@ -0,0 +1,49 @@
+import { Directive, Host, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-sirio-lib";
+export class TabDirective {
+    sirioTab;
+    tabCount = 0;
+    constructor(sirioTab) {
+        this.sirioTab = sirioTab;
+    }
+    ngOnChanges(changes) {
+        if (changes["tabCount"]) {
+            const previous = changes["tabCount"].previousValue;
+            if (previous === undefined)
+                return;
+            const current = changes["tabCount"].currentValue;
+            setTimeout(() => {
+                this.sirioTab.setContentItemIndex();
+                this.sirioTab.showArrowIfNeeded();
+                if (previous < current) {
+                    this.sirioTab.setActiveIndex(current - 1);
+                }
+                else {
+                    if (this.sirioTab.oldIndex == current) {
+                        // remove last
+                        this.sirioTab.setActiveIndex(current - 1);
+                    }
+                    else if (this.sirioTab.oldIndex < current) {
+                        // remove middle
+                        this.sirioTab.setActiveIndex(this.sirioTab.oldIndex);
+                    }
+                }
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TabDirective, deps: [{ token: i1.SirioTabComponent, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TabDirective, isStandalone: true, selector: "[tabCount]", inputs: { tabCount: "tabCount" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TabDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tabCount]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.SirioTabComponent, decorators: [{
+                    type: Host
+                }] }], propDecorators: { tabCount: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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