@wemake4u/form-player-se 1.0.0

package/esm2022/lib/dataSources/odata.mjs

@@ -0,0 +1,131 @@
+import { HttpParams } from '@angular/common/http';
+export class ODataSource {
+    url;
+    http;
+    constructor(url, http) {
+        this.url = url;
+        this.http = http;
+    }
+    getRows(params) {
+        const queryString = this.getQueryString(params);
+        let queryUrl = `${this.url}${queryString}`;
+        this.http.get(queryUrl, { observe: 'response' }).subscribe({
+            next: response => {
+                const data = response.body ?? [];
+                const count = response.headers.get('X-Total-Count');
+                params.successCallback(data, this.toNumber(count));
+            },
+            error: error => {
+                console.log(error);
+                params.failCallback();
+            }
+        });
+    }
+    getQueryString(params) {
+        let queryParams = new HttpParams();
+        queryParams = this.addCount(queryParams);
+        queryParams = this.addSkipAndTake(params, queryParams);
+        queryParams = this.addOrderBy(params, queryParams);
+        queryParams = this.addFilterBy(params, queryParams);
+        const queryString = queryParams.toString();
+        return queryString ? "?" + queryString : queryString;
+    }
+    addCount(queryParams) {
+        return queryParams.set("$count", "true");
+    }
+    addSkipAndTake(params, queryParams) {
+        return queryParams
+            .set("$top", `${params.endRow - params.startRow}`)
+            .set("$skip", `${params.startRow}`);
+    }
+    addOrderBy(params, queryParams) {
+        if (!params.sortModel || params.sortModel.length === 0) {
+            return queryParams;
+        }
+        const orderByParams = params.sortModel
+            .map(sort => `${sort.colId} ${sort.sort}`)
+            .join(",");
+        return queryParams.set("$orderby", orderByParams);
+    }
+    addFilterBy(params, queryParams) {
+        const filterModel = params.filterModel;
+        if (!filterModel || Object.keys(filterModel).length === 0) {
+            return queryParams;
+        }
+        const filters = [];
+        for (const column in filterModel) {
+            const filter = filterModel[column];
+            const condition = this.getCondition(column, filter);
+            if (condition) {
+                filters.push(condition);
+            }
+        }
+        return queryParams.set("$filter", filters.join(" and "));
+    }
+    getCondition(column, filter) {
+        if (filter.operator === "AND" || filter.operator === "OR") {
+            if (Array.isArray(filter.conditions)) {
+                return "(" + filter.conditions.map((subfilter) => this.getCondition(column, subfilter))
+                    .join(` ${filter.operator.toLowerCase()} `) + ")";
+            }
+            return null;
+        }
+        const value = filter.filter;
+        switch (filter.filterType) {
+            case "text":
+                const text = (value ?? "").replace(/'/g, "''");
+                if (filter.type === "contains") {
+                    return `contains(${column}, '${text}')`;
+                }
+                else if (filter.type === "notContains") {
+                    return `not contains(${column}, '${text}')`;
+                }
+                else if (filter.type === "equals") {
+                    return `${column} eq '${text}'`;
+                }
+                else if (filter.type === "notEqual") {
+                    return `${column} ne '${text}'`;
+                }
+                else if (filter.type === "startsWith") {
+                    return `startswith(${column}, '${text}')`;
+                }
+                else if (filter.type === "endsWith") {
+                    return `endswith(${column}, '${text}')`;
+                }
+                else if (filter.type === "blank") {
+                    return `${column} eq null`;
+                }
+                else if (filter.type === "notBlank") {
+                    return `${column} ne null`;
+                }
+                break;
+            case "number":
+                if (filter.type === "equals") {
+                    return `${column} eq ${value}`;
+                }
+                else if (filter.type === "greaterThan") {
+                    return `${column} gt ${value}`;
+                }
+                else if (filter.type === "lessThan") {
+                    return `${column} lt ${value}`;
+                }
+                else if (filter.type === "greaterThanOrEqual") {
+                    return `${column} ge ${value}`;
+                }
+                else if (filter.type === "lessThanOrEqual") {
+                    return `${column} le ${value}`;
+                }
+                break;
+            case "date":
+                return `${column} eq ${value}`; // Modifica se OData usa formati ISO
+        }
+        return null;
+    }
+    toNumber(value) {
+        if (!value)
+            return undefined;
+        const num = parseFloat(value);
+        return isNaN(num) ? undefined : num;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"odata.js","sourceRoot":"","sources":["../../../../../projects/ngx-sirio/src/lib/dataSources/odata.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpParams } from '@angular/common/http';\r\nimport { IGetRowsParams } from 'ag-grid-community';\r\nimport { IRowsSource } from './interfaces';\r\n\r\nexport class ODataSource implements IRowsSource  {\r\n  constructor(private url: string\r\n    , private http: HttpClient) {\r\n  }\r\n\r\n  getRows(params: IGetRowsParams) {\r\n    const queryString = this.getQueryString(params);\r\n\r\n    let queryUrl = `${this.url}${queryString}`\r\n\r\n    this.http.get<any>(queryUrl, { observe: 'response' }).subscribe({\r\n      next: response => {\r\n        const data = response.body ?? [];\r\n        const count = response.headers.get('X-Total-Count');\r\n        params.successCallback(data, this.toNumber(count));\r\n      },\r\n      error: error => {\r\n        console.log(error);\r\n        params.failCallback();\r\n      }\r\n    });\r\n  }\r\n\r\n  private getQueryString(params: IGetRowsParams): string {\r\n    let queryParams = new HttpParams();\r\n    queryParams = this.addCount(queryParams);\r\n    queryParams = this.addSkipAndTake(params, queryParams);\r\n    queryParams = this.addOrderBy(params, queryParams);\r\n    queryParams = this.addFilterBy(params, queryParams);\r\n\r\n    const queryString = queryParams.toString();\r\n    return queryString ? \"?\" + queryString : queryString;\r\n  }\r\n\r\n  private addCount(queryParams: HttpParams): HttpParams {\r\n    return queryParams.set(\"$count\", \"true\");\r\n  }\r\n\r\n  private addSkipAndTake(params: IGetRowsParams, queryParams: HttpParams): HttpParams {\r\n    return queryParams\r\n      .set(\"$top\", `${params.endRow - params.startRow}`)\r\n      .set(\"$skip\", `${params.startRow}`);\r\n  }\r\n\r\n  private addOrderBy(params: IGetRowsParams, queryParams: HttpParams): HttpParams {\r\n    if (!params.sortModel || params.sortModel.length === 0) {\r\n      return queryParams;\r\n    }\r\n\r\n    const orderByParams = params.sortModel\r\n      .map(sort => `${sort.colId} ${sort.sort}`)\r\n      .join(\",\");\r\n\r\n    return queryParams.set(\"$orderby\", orderByParams);\r\n  }\r\n\r\n  private addFilterBy(params: IGetRowsParams, queryParams: HttpParams): HttpParams {\r\n\r\n    const filterModel = params.filterModel;\r\n\r\n    if (!filterModel || Object.keys(filterModel).length === 0) {\r\n      return queryParams;\r\n    }\r\n\r\n    const filters: string[] = [];\r\n\r\n    for (const column in filterModel) {\r\n      const filter = filterModel[column];\r\n\r\n      const condition = this.getCondition(column, filter);\r\n\r\n      if (condition) {\r\n        filters.push(condition);\r\n      }\r\n    }\r\n\r\n    return queryParams.set(\"$filter\", filters.join(\" and \"));\r\n  }\r\n\r\n  private getCondition(column: string, filter: any): string | null {\r\n\r\n    if (filter.operator === \"AND\" || filter.operator === \"OR\") {\r\n      if (Array.isArray(filter.conditions)) {\r\n        return \"(\" + filter.conditions.map((subfilter: any) => this.getCondition(column, subfilter))\r\n          .join(` ${filter.operator.toLowerCase()} `) + \")\";\r\n      }\r\n      return null;\r\n    }\r\n\r\n    const value = filter.filter;\r\n\r\n    switch (filter.filterType) {\r\n      case \"text\":\r\n        const text = (value ?? \"\").replace(/'/g, \"''\");\r\n        if (filter.type === \"contains\") {\r\n          return `contains(${column}, '${text}')`;\r\n        } else if (filter.type === \"notContains\") {\r\n          return `not contains(${column}, '${text}')`;\r\n        } else if (filter.type === \"equals\") {\r\n          return `${column} eq '${text}'`;\r\n        } else if (filter.type === \"notEqual\") {\r\n          return `${column} ne '${text}'`;\r\n        } else if (filter.type === \"startsWith\") {\r\n          return `startswith(${column}, '${text}')`;\r\n        } else if (filter.type === \"endsWith\") {\r\n          return `endswith(${column}, '${text}')`;\r\n        } else if (filter.type === \"blank\") {\r\n          return `${column} eq null`;\r\n        } else if (filter.type === \"notBlank\") {\r\n          return `${column} ne null`;\r\n        }\r\n        break;\r\n\r\n      case \"number\":\r\n        if (filter.type === \"equals\") {\r\n          return `${column} eq ${value}`;\r\n        } else if (filter.type === \"greaterThan\") {\r\n          return `${column} gt ${value}`;\r\n        } else if (filter.type === \"lessThan\") {\r\n          return `${column} lt ${value}`;\r\n        } else if (filter.type === \"greaterThanOrEqual\") {\r\n          return `${column} ge ${value}`;\r\n        } else if (filter.type === \"lessThanOrEqual\") {\r\n          return `${column} le ${value}`;\r\n        }\r\n        break;\r\n\r\n      case \"date\":\r\n        return `${column} eq ${value}`; // Modifica se OData usa formati ISO\r\n    }\r\n\r\n    return null;\r\n  }\r\n\r\n  private toNumber(value: string | null): number | undefined {\r\n    if (!value)\r\n      return undefined;\r\n    const num = parseFloat(value);\r\n    return isNaN(num) ? undefined : num;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/dataSources/rest.mjs

@@ -0,0 +1,48 @@
+import { HttpParams } from '@angular/common/http';
+import { map } from 'rxjs/operators';
+export class RestDataSource {
+    http;
+    baseUrl;
+    params = {};
+    mapFn;
+    constructor(http, baseUrl) {
+        this.http = http;
+        this.baseUrl = baseUrl;
+    }
+    setParam(key, value) {
+        if (value !== undefined && value !== null) {
+            this.params[key] = value;
+        }
+        else {
+            delete this.params[key];
+        }
+        return this;
+    }
+    setParams(params) {
+        this.params = { ...params };
+        return this;
+    }
+    setMapFunction(mapFn) {
+        this.mapFn = mapFn;
+        return this;
+    }
+    getMapFunction() {
+        return this.mapFn;
+    }
+    getParam(key) {
+        return this.params[key];
+    }
+    getParams() {
+        return this.params;
+    }
+    getData() {
+        let httpParams = new HttpParams();
+        Object.keys(this.params).forEach(key => {
+            if (this.params[key] !== undefined && this.params[key] !== null) {
+                httpParams = httpParams.set(key, this.params[key].toString());
+            }
+        });
+        return this.http.get(this.baseUrl, { params: httpParams }).pipe(map(responseArray => this.mapFn ? responseArray.map(item => this.mapFn(item)) : responseArray));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,52 @@
+import { Directive, Host, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-sirio-lib";
+export class AccordionDirective {
+    sirioAccordion;
+    accordionCount = 0;
+    constructor(sirioAccordion) {
+        this.sirioAccordion = sirioAccordion;
+    }
+    ngOnChanges(changes) {
+        if (changes["accordionCount"]) {
+            const previous = changes["accordionCount"].previousValue;
+            if (previous === undefined)
+                return;
+            const current = changes["accordionCount"].currentValue;
+            const oldIndex = this.sirioAccordion.panels.toArray().findIndex(panel => panel.panelIsOpen);
+            setTimeout(() => {
+                const event = new Event("");
+                this.sirioAccordion.closePanels(event);
+                const panels = this.sirioAccordion.panels.toArray();
+                const showPanel = (index) => panels[index].onPanelHeaderClicked(event);
+                if (previous < current) {
+                    showPanel(current - 1);
+                }
+                else {
+                    if (oldIndex == current) {
+                        // remove last
+                        showPanel(current - 1);
+                    }
+                    else if (oldIndex < current) {
+                        // remove middle
+                        showPanel(oldIndex);
+                    }
+                }
+            }, 100);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AccordionDirective, deps: [{ token: i1.SirioAccordionComponent, host: true }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: AccordionDirective, isStandalone: true, selector: "[accordionCount]", inputs: { accordionCount: "accordionCount" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AccordionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[accordionCount]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.SirioAccordionComponent, decorators: [{
+                    type: Host
+                }] }], propDecorators: { accordionCount: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,130 @@
+import { Input, Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AdornerDirective {
+    el;
+    renderer;
+    prefixAdorner = null;
+    suffixAdorner = null;
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    ngAfterViewInit() {
+        this.updatePrefix(this.prefixAdorner);
+        this.updateSuffix(this.suffixAdorner);
+    }
+    ngOnChanges(changes) {
+        if (changes["prefixAdorner"]) {
+            this.updatePrefix(changes["prefixAdorner"].currentValue);
+        }
+        if (changes["suffixAdorner"]) {
+            this.updateSuffix(changes["suffixAdorner"].currentValue);
+        }
+    }
+    getWrapper() {
+        return this.el.nativeElement.querySelector('div.sirio-input-group');
+    }
+    ;
+    isPrepared() {
+        return this.getWrapper() !== null;
+    }
+    prepare() {
+        if (this.isPrepared())
+            return this.getWrapper();
+        const inputElement = this.el.nativeElement.querySelector('input');
+        if (!inputElement)
+            return null;
+        const wrapper = this.renderer.createElement('div');
+        this.renderer.addClass(wrapper, 'sirio-input-group');
+        const parent = inputElement.parentNode;
+        this.renderer.insertBefore(parent, wrapper, inputElement);
+        this.renderer.appendChild(wrapper, inputElement);
+        return wrapper;
+    }
+    updatePrefix(prefixAdorner) {
+        const prefixText = this.normalizeText(prefixAdorner);
+        this.remove("span.prefix");
+        if (prefixText !== null) {
+            const wrapper = this.prepare();
+            if (wrapper) {
+                const inputElement = wrapper.querySelector('input');
+                const prefixSpan = this.createSpanElement(prefixText);
+                this.renderer.addClass(prefixSpan, "prefix");
+                this.renderer.insertBefore(wrapper, prefixSpan, inputElement);
+            }
+        }
+    }
+    updateSuffix(suffixAdorner) {
+        const suffixText = this.normalizeText(suffixAdorner);
+        this.remove("span.suffix");
+        if (suffixText !== null) {
+            const wrapper = this.prepare();
+            if (wrapper) {
+                const suffixSpan = this.createSpanElement(suffixText);
+                this.renderer.addClass(suffixSpan, "suffix");
+                this.renderer.appendChild(wrapper, suffixSpan);
+            }
+        }
+    }
+    remove(selector) {
+        const wrapper = this.getWrapper();
+        if (!wrapper)
+            return;
+        const span = wrapper.querySelector(selector);
+        if (span)
+            this.renderer.removeChild(wrapper, span);
+    }
+    createSpanElement(adorner) {
+        const outerSpan = this.renderer.createElement('span');
+        this.renderer.addClass(outerSpan, 'sirio-input-group-text');
+        const innerSpan = this.renderer.createElement('span');
+        this.renderer.setAttribute(innerSpan, 'aria-hidden', 'true');
+        const iconClass = this.getIconClassName(adorner);
+        if (iconClass) {
+            this.renderer.addClass(innerSpan, 'fas');
+            this.renderer.addClass(innerSpan, iconClass);
+        }
+        else {
+            const strongElement = this.renderer.createElement('strong');
+            this.renderer.appendChild(innerSpan, strongElement);
+            const text = this.renderer.createText(adorner);
+            this.renderer.appendChild(strongElement, text);
+        }
+        this.renderer.appendChild(outerSpan, innerSpan);
+        return outerSpan;
+    }
+    ;
+    getIconClassName(text) {
+        switch (text) {
+            case "%":
+                return "fa-percent";
+            case "@":
+                return "fa-envelope";
+            case "€":
+                return "fa-euro-sign";
+        }
+        return null;
+    }
+    ;
+    normalizeText(text) {
+        if (text) {
+            const trimmedValue = text.trim();
+            return trimmedValue.length > 0 ? trimmedValue : null;
+        }
+        return null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdornerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: AdornerDirective, isStandalone: true, selector: "[prefixAdorner], [suffixAdorner]", inputs: { prefixAdorner: "prefixAdorner", suffixAdorner: "suffixAdorner" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AdornerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[prefixAdorner], [suffixAdorner]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { prefixAdorner: [{
+                type: Input
+            }], suffixAdorner: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"adorner.directive.js","sourceRoot":"","sources":["../../../../../projects/ngx-sirio/src/lib/directives/adorner.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, Directive, ElementRef, Renderer2, AfterViewInit, OnChanges, SimpleChanges } from '@angular/core';\r\n\r\n@Directive({\r\n  selector: '[prefixAdorner], [suffixAdorner]',\r\n  standalone: true\r\n})\r\nexport class AdornerDirective implements OnChanges, AfterViewInit {\r\n  @Input() prefixAdorner: string | null = null;\r\n  @Input() suffixAdorner: string | null = null;\r\n\r\n  constructor(private el: ElementRef, private renderer: Renderer2) { }\r\n\r\n  ngAfterViewInit(): void {\r\n    this.updatePrefix(this.prefixAdorner);\r\n    this.updateSuffix(this.suffixAdorner);    \r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes[\"prefixAdorner\"]) {\r\n      this.updatePrefix(changes[\"prefixAdorner\"].currentValue);\r\n    }\r\n\r\n    if (changes[\"suffixAdorner\"]) {\r\n      this.updateSuffix(changes[\"suffixAdorner\"].currentValue);\r\n    }\r\n  }\r\n\r\n  private getWrapper() {\r\n    return this.el.nativeElement.querySelector('div.sirio-input-group');\r\n  };\r\n\r\n  private isPrepared(): boolean {\r\n    return this.getWrapper() !== null;\r\n  }\r\n\r\n  private prepare(): any {\r\n    if (this.isPrepared())\r\n      return this.getWrapper();\r\n\r\n    const inputElement = this.el.nativeElement.querySelector('input');\r\n\r\n    if (!inputElement)\r\n      return null;\r\n\r\n    const wrapper = this.renderer.createElement('div');\r\n    this.renderer.addClass(wrapper, 'sirio-input-group');\r\n\r\n    const parent = inputElement.parentNode;\r\n    this.renderer.insertBefore(parent, wrapper, inputElement);\r\n\r\n    this.renderer.appendChild(wrapper, inputElement);\r\n\r\n    return wrapper;\r\n  }\r\n\r\n  private updatePrefix(prefixAdorner: string | null)\r\n  {\r\n    const prefixText = this.normalizeText(prefixAdorner);\r\n\r\n    this.remove(\"span.prefix\");\r\n    \r\n    if (prefixText !== null) {\r\n      const wrapper = this.prepare();\r\n      if (wrapper) {\r\n        const inputElement = wrapper.querySelector('input');\r\n        const prefixSpan = this.createSpanElement(prefixText);\r\n        this.renderer.addClass(prefixSpan, \"prefix\")\r\n        this.renderer.insertBefore(wrapper, prefixSpan, inputElement);\r\n      }     \r\n    }\r\n  }\r\n\r\n  private updateSuffix(suffixAdorner: string | null) {\r\n    const suffixText = this.normalizeText(suffixAdorner);\r\n\r\n    this.remove(\"span.suffix\");\r\n\r\n    if (suffixText !== null) {\r\n      const wrapper = this.prepare();\r\n      if (wrapper) {\r\n        const suffixSpan = this.createSpanElement(suffixText);\r\n        this.renderer.addClass(suffixSpan, \"suffix\")\r\n        this.renderer.appendChild(wrapper, suffixSpan);\r\n      }\r\n    }\r\n  }\r\n\r\n  private remove(selector: string) {\r\n    const wrapper = this.getWrapper();\r\n    if (!wrapper)\r\n      return;\r\n    const span = wrapper.querySelector(selector);\r\n    if (span)\r\n      this.renderer.removeChild(wrapper, span);\r\n  }\r\n\r\n  private createSpanElement(adorner: string) {\r\n    const outerSpan = this.renderer.createElement('span');\r\n    this.renderer.addClass(outerSpan, 'sirio-input-group-text');\r\n    \r\n    const innerSpan = this.renderer.createElement('span');\r\n    this.renderer.setAttribute(innerSpan, 'aria-hidden', 'true');\r\n\r\n    const iconClass = this.getIconClassName(adorner);\r\n\r\n    if (iconClass) {\r\n      this.renderer.addClass(innerSpan, 'fas');\r\n      this.renderer.addClass(innerSpan, iconClass);\r\n    }\r\n    else {\r\n      const strongElement = this.renderer.createElement('strong');\r\n      this.renderer.appendChild(innerSpan, strongElement);\r\n\r\n      const text = this.renderer.createText(adorner);\r\n      this.renderer.appendChild(strongElement, text);\r\n    }\r\n\r\n    this.renderer.appendChild(outerSpan, innerSpan);\r\n\r\n    return outerSpan;\r\n  };\r\n\r\n  private getIconClassName(text: string) {\r\n\r\n    switch (text) {\r\n      case \"%\":\r\n        return \"fa-percent\";\r\n\r\n      case \"@\":\r\n        return \"fa-envelope\";\r\n\r\n      case \"€\":\r\n        return \"fa-euro-sign\";\r\n    }\r\n\r\n    return null;\r\n  };\r\n\r\n  private normalizeText(text: string | null): string | null {\r\n\r\n    if (text) {\r\n      const trimmedValue = text.trim();\r\n      return trimmedValue.length > 0 ? trimmedValue : null;\r\n    }\r\n\r\n    return null;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/directives/disable.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 DisableDirective {
+    ngControl;
+    disableControl = null;
+    readonly = null;
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+    }
+    ngOnChanges(changes) {
+        if (changes["disableControl"] || changes["readonly"]) {
+            if (this.ngControl.control) {
+                if (this.disableControl) {
+                    this.ngControl.control.disable();
+                }
+                else {
+                    this.ngControl.control.enable();
+                    this.ngControl.valueAccessor?.setDisabledState(this.readonly === true);
+                }
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DisableDirective, deps: [{ token: i1.NgControl }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DisableDirective, isStandalone: true, selector: "[disableControl], [readonly]", inputs: { disableControl: "disableControl", readonly: "readonly" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DisableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[disableControl], [readonly]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl }], propDecorators: { disableControl: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,46 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DisplayDirective {
+    el;
+    renderer;
+    hide = null;
+    show = null;
+    constructor(el, renderer) {
+        this.el = el;
+        this.renderer = renderer;
+    }
+    ngOnChanges(changes) {
+        if (changes["hide"]) {
+            const value = changes["hide"].currentValue;
+            if (value === true) {
+                this.renderer.setStyle(this.el.nativeElement, 'display', 'none');
+            }
+            else if (value === false) {
+                this.renderer.setStyle(this.el.nativeElement, 'display', 'block');
+            }
+        }
+        if (changes["show"]) {
+            const value = changes["show"].currentValue;
+            if (value === true) {
+                this.renderer.setStyle(this.el.nativeElement, 'display', 'block');
+            }
+            else if (value === false) {
+                this.renderer.setStyle(this.el.nativeElement, 'display', 'none');
+            }
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DisplayDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DisplayDirective, isStandalone: true, selector: "[hide], [show]", inputs: { hide: "hide", show: "show" }, usesOnChanges: true, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DisplayDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[hide], [show]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.Renderer2 }], propDecorators: { hide: [{
+                type: Input
+            }], show: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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