@wertzui/ngx-restworld-client 12.1.2 → 12.2.1

package/esm2022/lib/components/restworld-form/restworld-form.component.mjs

@@ -173,13 +173,22 @@ export class RestWorldFormComponent {
                 }
                 this._messageService.add({ severity: 'error', summary: summary, detail: detail, data: response, sticky: true });
             }
+            else if (response.status == 201) {
+                if (!response.headers.has('Location')) {
+                    this._messageService.add({ severity: 'error', summary: 'Error', detail: 'The server returned a 201 Created response, but did not return a Location header.', data: response, sticky: true });
+                    return;
+                }
+                this._messageService.add({ severity: 'success', summary: 'Created', detail: 'The resource has been created.' });
+                var createdAtUri = response.headers.get('Location');
+                this.afterSubmit.emit({ location: createdAtUri, status: 201 });
+            }
             else {
                 const templateBeforeSubmit = this.template;
                 const responseResource = response.body;
                 this.template = responseResource.getTemplateByTitle(this.template.title);
                 this._formGroup = this._formService.createFormGroupFromTemplate(this.template);
                 this._messageService.add({ severity: 'success', summary: 'Saved', detail: 'The resource has been saved.' });
-                this.afterSubmit.emit({ old: templateBeforeSubmit, new: this.template });
+                this.afterSubmit.emit({ old: templateBeforeSubmit, new: this.template, status: 200 });
             }
         }
         catch (e) {
@@ -247,4 +256,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImpor
                 type: ContentChild,
                 args: ['buttons', { static: false }]
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restworld-form.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-form/restworld-form.component.ts","../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-form/restworld-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ContentChild, ElementRef, EventEmitter, Input, OnInit, Output, TemplateRef } from '@angular/core';\nimport { AbstractControl, FormGroup, UntypedFormArray, UntypedFormGroup } from '@angular/forms';\nimport { FormService, FormsResource, ProblemDetails, PropertyDto, SimpleValue, Template } from '@wertzui/ngx-hal-client';\nimport { ConfirmationService, MessageService } from 'primeng/api';\nimport { RestWorldClient } from '../../services/restworld-client';\nimport { RestWorldClientCollection } from '../../services/restworld-client-collection';\n\n/**\n * A form with Save, Reload and Delete buttons.\n * If you do not want buttons, use RestWorldFormTemplateComponent <rw-form-template>.\n * You can also provide your own buttons by passing in a template.\n */\n@Component({\n  selector: 'rw-form',\n  templateUrl: './restworld-form.component.html',\n  styleUrls: ['./restworld-form.component.css']\n})\nexport class RestWorldFormComponent<TPropertyDtos extends ReadonlyArray<PropertyDto<SimpleValue, string, string>>> implements OnInit{\n  /**\n   * The template used to render the form.\n   */\n  @Input({ required: true })\n  template!: Template<TPropertyDtos>;\n\n  @Input({ required: true })\n  apiName!: string;\n\n  @Input({ required: true })\n  rel!: string;\n\n  /**\n   * Determines whether to enable the submit button.\n  */\n  @Input()\n  allowSubmit = true;\n\n  /**\n   * Determines whether to enable the delete button.\n  */\n  @Input()\n  allowDelete = true;\n\n  /**\n   * Determines whether to enable the reload button.\n  */\n  @Input()\n  allowReload = true;\n\n  /**\n   * Determines whether to show the submit button.\n  */\n  @Input()\n  showSubmit = true;\n\n  /**\n   * Determines whether to show the delete button.\n  */\n  @Input()\n  showDelete = true;\n\n  /**\n   * Determines whether to show the reload button.\n  */\n  @Input()\n  showReload = true;\n\n  @Output()\n  afterDelete = new EventEmitter<void>();\n\n  @Output()\n  afterSubmit = new EventEmitter<{old: Template, new: Template}>();\n\n  /**\n   * A reference to a template that can be used to render custom buttons for the form.\n  */\n  @ContentChild('buttons', { static: false })\n  buttonsRef?: TemplateRef<unknown>;\n\n  scrollToFirstValidationError(): void {\n    setTimeout(() => {\n      const validationErrorElements = this._elementRef.nativeElement.querySelectorAll('rw-validation-errors>val-errors>div')\n      const firstError = validationErrorElements[0];\n      firstError.scrollIntoView({ behavior: 'smooth', block: 'center'});\n    },\n    100);\n  }\n\n  private _isLoading = false;\n  public get isLoading(): boolean {\n    return this._isLoading;\n  }\n\n  private _formGroup?: FormGroup<any>;\n  public get formGroup(): FormGroup<any> | undefined {\n    return this._formGroup;\n  }\n\n  public get canSubmit() : boolean {\n    return this.allowSubmit &&\n      this.template.target !== undefined &&\n      !this.isLoading &&\n      this.formGroup !== undefined &&\n      this.formGroup.valid;\n  }\n\n  public get canDelete(): boolean {\n    return this.allowDelete &&\n      this.template.target !== undefined &&\n      this.template.method == \"PUT\" &&\n      !this.isLoading;\n  }\n\n  public get canReload(): boolean {\n    return this.allowReload &&\n      this.template.target !== undefined &&\n      this.template.title !== undefined &&\n      this.template.properties.some(p => p.name === \"id\" && p.value !== undefined && p.value !== null && p.value !== 0) &&\n      !this.isLoading;\n  }\n\n  constructor(\n    private readonly _clients: RestWorldClientCollection,\n    private readonly _confirmationService: ConfirmationService,\n    private readonly _messageService: MessageService,\n    private readonly _formService: FormService,\n    private readonly _elementRef: ElementRef<HTMLElement>) {\n  }\n\n  ngOnInit(): void {\n    this._formGroup = this._formService.createFormGroupFromTemplate(this.template);\n  }\n\n  public async reload(): Promise<void> {\n    if (!this.canReload)\n      return;\n\n    this._isLoading = true;\n\n    try\n    {\n      const response = await this.getClient().getForm(this.template.target!);\n      if (!response.ok || ProblemDetails.isProblemDetails(response.body) || !response.body) {\n        this._messageService.add({ severity: 'error', summary: 'Error', detail: 'Error while loading the resource from the API.', data: response, sticky: true });\n      }\n      else {\n        this.template = response.body.getTemplateByTitle(this.template.title!) as Template<TPropertyDtos>;\n        this._formGroup = this._formService.createFormGroupFromTemplate(this.template);\n      }\n    }\n    catch (e: unknown) {\n      this._messageService.add({ severity: 'error', summary: 'Error', detail: `An unknown error occurred. ${JSON.stringify(e)}`, sticky: true });\n      console.log(e);\n    }\n\n    this._isLoading = false;\n  }\n\n  public showDeleteConfirmatioModal() {\n    this._confirmationService.confirm({\n      message: 'Do you really want to delete this resource?',\n      header: 'Confirm delete',\n      icon: 'far fa-trash-alt',\n      accept: () => this.delete()\n    });\n  }\n\n  public async submit() {\n    if( this.formGroup !== undefined)\n    {\n      this.formGroup.markAllAsTouched();\n\n      if (!this.formGroup.valid) {\n        this._messageService.add({\n          severity: 'error',\n          summary: 'Error',\n          detail: 'Please correct the errors before submitting.',\n        });\n\n        this.scrollToFirstValidationError();\n      }\n    }\n\n    if(!this.canSubmit)\n      return;\n\n    this._isLoading = true;\n\n    try {\n      const response = await this.getClient().submit(this.template, this.formGroup!.value);\n\n      if (!response.ok) {\n        let summary = 'Error';\n        let detail = 'Error while saving the resource.';\n        if (ProblemDetails.isProblemDetails(response.body)) {\n          const problemDetails = response.body as ProblemDetails;\n          summary = problemDetails.title || summary;\n          detail = problemDetails.detail || detail;\n          // display validation errors\n          if (problemDetails['errors'] as {}) {\n            for (const [key, errorsForKey] of Object.entries(problemDetails['errors'] as {})) {\n              const path = key.split(/\\.|\\[/).map(e => e.replace(\"]\", \"\"));\n              // The path might start with a $, indicating the root.\n              if (path.length > 0 && path[0] === '$')\n                path.shift();\n              const formControl = path.reduce<AbstractControl | undefined>(RestWorldFormComponent.getSubControl, this.formGroup);\n              if (formControl) {\n                formControl.setErrors({ ...formControl.errors, ...{ remote: errorsForKey } });\n                formControl.markAsTouched();\n              }\n            }\n          }\n        }\n\n        this._messageService.add({ severity: 'error', summary: summary, detail: detail, data: response, sticky: true });\n      }\n      else {\n        const templateBeforeSubmit = this.template;\n        const responseResource = (response.body as FormsResource);\n        this.template = responseResource.getTemplateByTitle(this.template.title!) as Template<TPropertyDtos>;\n        this._formGroup = this._formService.createFormGroupFromTemplate(this.template);\n\n        this._messageService.add({ severity: 'success', summary: 'Saved', detail: 'The resource has been saved.' });\n\n        this.afterSubmit.emit({old: templateBeforeSubmit, new: this.template});\n      }\n    }\n    catch (e: unknown) {\n      this._messageService.add({ severity: 'error', summary: 'Error', detail: `An unknown error occurred. ${JSON.stringify(e)}`, sticky: true });\n      console.log(e);\n    }\n\n    this._isLoading = false;\n  }\n\n  public async delete(): Promise<void> {\n    if (!this.canDelete)\n      return;\n\n    if (this.formGroup === undefined)\n      throw new Error(\"formGroup cannot be undefined.\");\n\n    await this.getClient().deleteByTemplateAndForm(this.template, this.formGroup);\n    this._messageService.add({ severity: 'success', summary: 'Deleted', detail: 'The resource has been deleted.' })\n\n    this.afterDelete.emit();\n  }\n\n  private static getSubControl(control: AbstractControl | undefined, pathElement: string): AbstractControl | undefined {\n    if (pathElement === \"\")\n      return control;\n\n    if (control instanceof UntypedFormGroup)\n      return control.controls[pathElement];\n\n    if (control instanceof UntypedFormArray) {\n      const index = Number.parseInt(pathElement);\n      if (Number.isInteger(index))\n        return control.controls[index];\n    }\n\n    return control;\n  }\n\n  private getClient(): RestWorldClient {\n    return this._clients.getClient(this.apiName);\n  }\n}\n","<form *ngIf=\"formGroup !== undefined && template !== undefined\" [formGroup]=\"formGroup\" (ngSubmit)=\"submit()\">\n  <div class=\"blockable-container\">\n    <div class=\"blockable-element\">\n      <div class=\"grid field\">\n        <div class=\"col-12 md:col-10 md:col-offset-2\">\n          <rw-validation-errors [form]=\"formGroup\"></rw-validation-errors>\n        </div>\n      </div>\n      <rw-input-template [template]=\"template\" [apiName]=\"apiName\"></rw-input-template>\n    </div>\n    <div class=\"blockable-overlay\" *ngIf=\"isLoading\">\n      <p-progressSpinner></p-progressSpinner>\n    </div>\n  </div>\n\n  <div class=\"grid\">\n    <div class=\"col\">\n      <div class=\"flex justify-content-end w-full\">\n        <ng-template #defaultButtons>\n          <button pButton pRipple type=\"submit\" label=\"Save\" icon=\"far fa-save\" class=\"mx-2 p-button-success\"\n            [disabled]=\"!allowSubmit\"></button>\n          <button pButton pRipple type=\"button\" label=\"Reload\" icon=\"fas fa-redo\" class=\"mx-2 p-button-info\"\n            (click)=\"reload()\" [disabled]=\"!canReload\"></button>\n          <button pButton pRipple type=\"button\" label=\"Delete\" icon=\"far fa-trash-alt\" class=\"ml-2 p-button-danger\"\n            (click)=\"showDeleteConfirmatioModal()\" [disabled]=\"!canDelete\"></button>\n        </ng-template>\n        <ng-container *ngTemplateOutlet=\"buttonsRef || defaultButtons\"></ng-container>\n      </div>\n    </div>\n  </div>\n</form>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restworld-form.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-form/restworld-form.component.ts","../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-form/restworld-form.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ContentChild, ElementRef, EventEmitter, Input, OnInit, Output, TemplateRef } from '@angular/core';\nimport { AbstractControl, FormGroup, UntypedFormArray, UntypedFormGroup } from '@angular/forms';\nimport { FormService, FormsResource, ProblemDetails, PropertyDto, SimpleValue, Template } from '@wertzui/ngx-hal-client';\nimport { ConfirmationService, MessageService } from 'primeng/api';\nimport { RestWorldClient } from '../../services/restworld-client';\nimport { RestWorldClientCollection } from '../../services/restworld-client-collection';\nimport { AfterSubmitOkEvent, AfterSubmitRedirectEvent } from '../../models/events';\n\n/**\n * A form with Save, Reload and Delete buttons.\n * If you do not want buttons, use RestWorldFormTemplateComponent <rw-form-template>.\n * You can also provide your own buttons by passing in a template.\n */\n@Component({\n  selector: 'rw-form',\n  templateUrl: './restworld-form.component.html',\n  styleUrls: ['./restworld-form.component.css']\n})\nexport class RestWorldFormComponent<TPropertyDtos extends ReadonlyArray<PropertyDto<SimpleValue, string, string>>> implements OnInit{\n  /**\n   * The template used to render the form.\n   */\n  @Input({ required: true })\n  template!: Template<TPropertyDtos>;\n\n  @Input({ required: true })\n  apiName!: string;\n\n  @Input({ required: true })\n  rel!: string;\n\n  /**\n   * Determines whether to enable the submit button.\n  */\n  @Input()\n  allowSubmit = true;\n\n  /**\n   * Determines whether to enable the delete button.\n  */\n  @Input()\n  allowDelete = true;\n\n  /**\n   * Determines whether to enable the reload button.\n  */\n  @Input()\n  allowReload = true;\n\n  /**\n   * Determines whether to show the submit button.\n  */\n  @Input()\n  showSubmit = true;\n\n  /**\n   * Determines whether to show the delete button.\n  */\n  @Input()\n  showDelete = true;\n\n  /**\n   * Determines whether to show the reload button.\n  */\n  @Input()\n  showReload = true;\n\n  @Output()\n  afterDelete = new EventEmitter<void>();\n\n  @Output()\n  afterSubmit = new EventEmitter<AfterSubmitOkEvent | AfterSubmitRedirectEvent>();\n\n  /**\n   * A reference to a template that can be used to render custom buttons for the form.\n  */\n  @ContentChild('buttons', { static: false })\n  buttonsRef?: TemplateRef<unknown>;\n\n  scrollToFirstValidationError(): void {\n    setTimeout(() => {\n      const validationErrorElements = this._elementRef.nativeElement.querySelectorAll('rw-validation-errors>val-errors>div')\n      const firstError = validationErrorElements[0];\n      firstError.scrollIntoView({ behavior: 'smooth', block: 'center'});\n    },\n    100);\n  }\n\n  private _isLoading = false;\n  public get isLoading(): boolean {\n    return this._isLoading;\n  }\n\n  private _formGroup?: FormGroup<any>;\n  public get formGroup(): FormGroup<any> | undefined {\n    return this._formGroup;\n  }\n\n  public get canSubmit() : boolean {\n    return this.allowSubmit &&\n      this.template.target !== undefined &&\n      !this.isLoading &&\n      this.formGroup !== undefined &&\n      this.formGroup.valid;\n  }\n\n  public get canDelete(): boolean {\n    return this.allowDelete &&\n      this.template.target !== undefined &&\n      this.template.method == \"PUT\" &&\n      !this.isLoading;\n  }\n\n  public get canReload(): boolean {\n    return this.allowReload &&\n      this.template.target !== undefined &&\n      this.template.title !== undefined &&\n      this.template.properties.some(p => p.name === \"id\" && p.value !== undefined && p.value !== null && p.value !== 0) &&\n      !this.isLoading;\n  }\n\n  constructor(\n    private readonly _clients: RestWorldClientCollection,\n    private readonly _confirmationService: ConfirmationService,\n    private readonly _messageService: MessageService,\n    private readonly _formService: FormService,\n    private readonly _elementRef: ElementRef<HTMLElement>) {\n  }\n\n  ngOnInit(): void {\n    this._formGroup = this._formService.createFormGroupFromTemplate(this.template);\n  }\n\n  public async reload(): Promise<void> {\n    if (!this.canReload)\n      return;\n\n    this._isLoading = true;\n\n    try\n    {\n      const response = await this.getClient().getForm(this.template.target!);\n      if (!response.ok || ProblemDetails.isProblemDetails(response.body) || !response.body) {\n        this._messageService.add({ severity: 'error', summary: 'Error', detail: 'Error while loading the resource from the API.', data: response, sticky: true });\n      }\n      else {\n        this.template = response.body.getTemplateByTitle(this.template.title!) as Template<TPropertyDtos>;\n        this._formGroup = this._formService.createFormGroupFromTemplate(this.template);\n      }\n    }\n    catch (e: unknown) {\n      this._messageService.add({ severity: 'error', summary: 'Error', detail: `An unknown error occurred. ${JSON.stringify(e)}`, sticky: true });\n      console.log(e);\n    }\n\n    this._isLoading = false;\n  }\n\n  public showDeleteConfirmatioModal() {\n    this._confirmationService.confirm({\n      message: 'Do you really want to delete this resource?',\n      header: 'Confirm delete',\n      icon: 'far fa-trash-alt',\n      accept: () => this.delete()\n    });\n  }\n\n  public async submit() {\n    if( this.formGroup !== undefined)\n    {\n      this.formGroup.markAllAsTouched();\n\n      if (!this.formGroup.valid) {\n        this._messageService.add({\n          severity: 'error',\n          summary: 'Error',\n          detail: 'Please correct the errors before submitting.',\n        });\n\n        this.scrollToFirstValidationError();\n      }\n    }\n\n    if(!this.canSubmit)\n      return;\n\n    this._isLoading = true;\n\n    try {\n      const response = await this.getClient().submit(this.template, this.formGroup!.value);\n\n      if (!response.ok) {\n        let summary = 'Error';\n        let detail = 'Error while saving the resource.';\n        if (ProblemDetails.isProblemDetails(response.body)) {\n          const problemDetails = response.body as ProblemDetails;\n          summary = problemDetails.title || summary;\n          detail = problemDetails.detail || detail;\n          // display validation errors\n          if (problemDetails['errors'] as {}) {\n            for (const [key, errorsForKey] of Object.entries(problemDetails['errors'] as {})) {\n              const path = key.split(/\\.|\\[/).map(e => e.replace(\"]\", \"\"));\n              // The path might start with a $, indicating the root.\n              if (path.length > 0 && path[0] === '$')\n                path.shift();\n              const formControl = path.reduce<AbstractControl | undefined>(RestWorldFormComponent.getSubControl, this.formGroup);\n              if (formControl) {\n                formControl.setErrors({ ...formControl.errors, ...{ remote: errorsForKey } });\n                formControl.markAsTouched();\n              }\n            }\n          }\n        }\n\n        this._messageService.add({ severity: 'error', summary: summary, detail: detail, data: response, sticky: true });\n      }\n      else if (response.status == 201) {\n        if (!response.headers.has('Location')) {\n          this._messageService.add({ severity: 'error', summary: 'Error', detail: 'The server returned a 201 Created response, but did not return a Location header.', data: response, sticky: true });\n          return;\n        }\n\n        this._messageService.add({ severity: 'success', summary: 'Created', detail: 'The resource has been created.' });\n\n        var createdAtUri = response.headers.get('Location')!;\n        this.afterSubmit.emit({ location: createdAtUri, status: 201 });\n      }\n      else {\n        const templateBeforeSubmit = this.template;\n        const responseResource = (response.body as FormsResource);\n        this.template = responseResource.getTemplateByTitle(this.template.title!) as Template<TPropertyDtos>;\n        this._formGroup = this._formService.createFormGroupFromTemplate(this.template);\n\n        this._messageService.add({ severity: 'success', summary: 'Saved', detail: 'The resource has been saved.' });\n\n        this.afterSubmit.emit({ old: templateBeforeSubmit, new: this.template, status: 200 });\n      }\n    }\n    catch (e: unknown) {\n      this._messageService.add({ severity: 'error', summary: 'Error', detail: `An unknown error occurred. ${JSON.stringify(e)}`, sticky: true });\n      console.log(e);\n    }\n\n    this._isLoading = false;\n  }\n\n  public async delete(): Promise<void> {\n    if (!this.canDelete)\n      return;\n\n    if (this.formGroup === undefined)\n      throw new Error(\"formGroup cannot be undefined.\");\n\n    await this.getClient().deleteByTemplateAndForm(this.template, this.formGroup);\n    this._messageService.add({ severity: 'success', summary: 'Deleted', detail: 'The resource has been deleted.' })\n\n    this.afterDelete.emit();\n  }\n\n  private static getSubControl(control: AbstractControl | undefined, pathElement: string): AbstractControl | undefined {\n    if (pathElement === \"\")\n      return control;\n\n    if (control instanceof UntypedFormGroup)\n      return control.controls[pathElement];\n\n    if (control instanceof UntypedFormArray) {\n      const index = Number.parseInt(pathElement);\n      if (Number.isInteger(index))\n        return control.controls[index];\n    }\n\n    return control;\n  }\n\n  private getClient(): RestWorldClient {\n    return this._clients.getClient(this.apiName);\n  }\n}\n","<form *ngIf=\"formGroup !== undefined && template !== undefined\" [formGroup]=\"formGroup\" (ngSubmit)=\"submit()\">\n  <div class=\"blockable-container\">\n    <div class=\"blockable-element\">\n      <div class=\"grid field\">\n        <div class=\"col-12 md:col-10 md:col-offset-2\">\n          <rw-validation-errors [form]=\"formGroup\"></rw-validation-errors>\n        </div>\n      </div>\n      <rw-input-template [template]=\"template\" [apiName]=\"apiName\"></rw-input-template>\n    </div>\n    <div class=\"blockable-overlay\" *ngIf=\"isLoading\">\n      <p-progressSpinner></p-progressSpinner>\n    </div>\n  </div>\n\n  <div class=\"grid\">\n    <div class=\"col\">\n      <div class=\"flex justify-content-end w-full\">\n        <ng-template #defaultButtons>\n          <button pButton pRipple type=\"submit\" label=\"Save\" icon=\"far fa-save\" class=\"mx-2 p-button-success\"\n            [disabled]=\"!allowSubmit\"></button>\n          <button pButton pRipple type=\"button\" label=\"Reload\" icon=\"fas fa-redo\" class=\"mx-2 p-button-info\"\n            (click)=\"reload()\" [disabled]=\"!canReload\"></button>\n          <button pButton pRipple type=\"button\" label=\"Delete\" icon=\"far fa-trash-alt\" class=\"ml-2 p-button-danger\"\n            (click)=\"showDeleteConfirmatioModal()\" [disabled]=\"!canDelete\"></button>\n        </ng-template>\n        <ng-container *ngTemplateOutlet=\"buttonsRef || defaultButtons\"></ng-container>\n      </div>\n    </div>\n  </div>\n</form>\n"]}

package/esm2022/lib/components/restworld-table/restworld-table.component.mjs

@@ -1,6 +1,7 @@
 import { Component, EventEmitter, Input, Optional, Output, ViewChild } from '@angular/core';
 import { PropertyType, Template } from '@wertzui/ngx-hal-client';
 import * as _ from 'lodash';
+import { FilterMatchMode } from 'primeng/api';
 import { ODataService } from '../../services/o-data.service';
 import { ControlContainer, FormArrayName } from '@angular/forms';
 import * as i0 from "@angular/core";
@@ -376,6 +377,14 @@ export class RestWorldTableComponent {
                 return ColumnFilterType.text;
         }
     }
+    toMatchMode(propertyType) {
+        // There is a bug in PrimeNG returning CONTAINS for boolean columns
+        // Once the bug has been fixed, we can remove this workaround
+        // https://github.com/primefaces/primeng/issues/14210
+        if (propertyType === PropertyType.Bool)
+            return FilterMatchMode.EQUALS;
+        return undefined;
+    }
     showInputField(column) {
         if (!this.isEditable)
             return false;
@@ -401,7 +410,7 @@ export class RestWorldTableComponent {
         this._editProperties = Object.fromEntries(this.editTemplate.properties.map(p => [p.name, p]));
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.6", ngImport: i0, type: RestWorldTableComponent, deps: [{ token: i1.ControlContainer }, { token: i2.FormService }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.6", type: RestWorldTableComponent, selector: "rw-table", inputs: { apiName: "apiName", formArray: "formArray", searchTemplate: "searchTemplate", editTemplate: "editTemplate", rows: "rows", rowsPerPageOptions: "rowsPerPageOptions", headerMenu: "headerMenu", rowMenu: "rowMenu", showRowMenuAsColumn: "showRowMenuAsColumn", showRowMenuOnRightClick: "showRowMenuOnRightClick", rowStyleClass: "rowStyleClass", cellStyleClass: "cellStyleClass", totalRecords: "totalRecords", styleClass: "styleClass", tableStyle: "tableStyle", scrollable: "scrollable", scrollHeight: "scrollHeight", selectionMode: "selectionMode", rowHover: "rowHover", selection: "selection", isLoading: "isLoading" }, outputs: { onFilterOrSortChanged: "onFilterOrSortChanged", onRowSelect: "onRowSelect", onRowUnselect: "onRowUnselect", selectionChange: "selectionChange" }, viewQueries: [{ propertyName: "contextMenu", first: true, predicate: ["contextMenu"], descendants: true }], ngImport: i0, template: "<p-table\n  #table\n  [value]=\"rows\"\n  [columns]=\"columns\"\n  [lazy]=\"true\"\n  [lazyLoadOnInit]=\"false\"\n  (onLazyLoad)=\"load($event)\"\n  responsiveLayout=\"scroll\"\n  [paginator]=\"true\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [rows]=\"rows.length\"\n  [totalRecords]=\"totalRecords\"\n  [loading]=\"isLoading\"\n  sortMode=\"multiple\"\n  [multiSortMeta]=\"multiSortMeta\"\n  [styleClass]=\"styleClass\"\n  [tableStyle]=\"tableStyle\"\n  [scrollable]=\"scrollable\"\n  [scrollHeight]=\"scrollHeight\"\n  [selectionMode]=\"selectionMode\"\n  (onRowSelect)=\"onRowSelectInternal($event)\"\n  (onRowUnselect)=\"onRowUnselectInternal($event)\"\n  [rowHover]=\"rowHover\"\n  [(selection)]=\"_selection\"\n  (selectionChange)=\"onSelectionChangeInternal($event)\">\n\n  <ng-template pTemplate=\"header\" let-columns>\n    <tr>\n        <th *ngFor=\"let col of columns\" [pSortableColumn]=\"col.name\">\n            <div class=\"p-d-flex p-jc-between p-ai-center\">\n                {{col.prompt}}\n                <ng-container *ngIf=\"!col.readOnly\">\n                  <p-sortIcon [field]=\"col.name\"></p-sortIcon>\n                  <p-columnFilter [type]=\"toColumnFilterType(col.type)\" [field]=\"col.name\" display=\"menu\"></p-columnFilter>\n                </ng-container>\n            </div>\n        </th>\n        <th *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button [items]=\"headerMenu\"></rw-menu-button>\n        </th>\n    </tr>\n  </ng-template>\n\n  <ng-template pTemplate=\"body\" let-entity let-columns=\"columns\" let-rowIndex=\"rowIndex\">\n    <tr (contextmenu)=\"openContextMenu($event, entity)\" [pSelectableRow]=\"entity\" [pSelectableRowDisabled]=\"selectionMode === null\" [className]=\"rowStyleClasses[rowIndex - (table.first ?? 0)]\">\n      <td [ngSwitch]=\"col.type\" *ngFor=\"let col of columns\" [className]=\"cellStyleClasses[rowIndex - (table.first ?? 0)][col.name]\">\n          <ng-container *ngIf=\"showInputField(col); else textField\" [formGroup]=\"formArray!.controls[rowIndex - (table.first ?? 0)]\" >\n            <rw-input [apiName]=\"apiName!\" [property]=\"editProperties[col.name]\"></rw-input>\n          </ng-container>\n          <ng-template #textField>\n            <ng-container *ngSwitchCase=\"PropertyType.Text\">\n                <rw-avatar *ngIf=\"col.name === 'createdBy' || col.name === 'lastChangedBy'\" [user]=\"entity[col.name]\"></rw-avatar>\n                <span *ngIf=\"col.name !== 'createdBy' && col.name !== 'lastChangedBy'\">{{entity[col.name]}}</span>\n            </ng-container>\n            <span *ngSwitchCase=\"PropertyType.Number\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Percent\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Currency\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Bool\" class=\"flex justify-content-center\"><p-triStateCheckbox [(ngModel)]=\"entity[col.name]\" [readonly]=\"true\"></p-triStateCheckbox></span>\n            <span *ngSwitchCase=\"PropertyType.Date\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Time\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Duration\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeLocal\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeOffset\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.Collection\" class=\"flex justify-content-end\"><p *ngFor=\"let arrayElement of entity[col.name]\">{{arrayElement | json}}</p></span>\n            <span *ngSwitchCase=\"PropertyType.Object\" class=\"flex justify-content-end\">{{entity[col.name] | json}}</span>\n            <span *ngSwitchDefault [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n          </ng-template>\n        </td>\n        <td *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button *ngIf=\"showRowMenuAsColumn\" [items]=\"rowMenus[rowIndex - (table.first ?? 0)]\"></rw-menu-button>\n        </td>\n    </tr>\n  </ng-template>\n\n  <p-contextMenu #contextMenu appendTo=\"body\" [model]=\"contextMenuItems\"></p-contextMenu>\n</p-table>\n", styles: [".p-tooltip{max-width:-moz-fit-content;max-width:fit-content}a.p-button{text-decoration:none}\n"], dependencies: [{ kind: "directive", type: i3.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i4.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i4.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "component", type: i5.ContextMenu, selector: "p-contextMenu", inputs: ["model", "triggerEvent", "target", "global", "style", "styleClass", "appendTo", "autoZIndex", "baseZIndex", "id", "ariaLabel", "ariaLabelledBy"], outputs: ["onShow", "onHide"] }, { kind: "directive", type: i6.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i7.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorStyleClass", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "groupRowsByOrder", "responsiveLayout", "breakpoint", "paginatorLocale", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "selectAll", "virtualRowHeight"], outputs: ["contextMenuSelectionChange", "selectAllChange", "selectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i7.SortableColumn, selector: "[pSortableColumn]", inputs: ["pSortableColumn", "pSortableColumnDisabled"] }, { kind: "directive", type: i7.SelectableRow, selector: "[pSelectableRow]", inputs: ["pSelectableRow", "pSelectableRowIndex", "pSelectableRowDisabled"] }, { kind: "component", type: i7.SortIcon, selector: "p-sortIcon", inputs: ["field"] }, { kind: "component", type: i7.ColumnFilter, selector: "p-columnFilter", inputs: ["field", "type", "display", "showMenu", "matchMode", "operator", "showOperator", "showClearButton", "showApplyButton", "showMatchModes", "showAddButton", "hideOnClear", "placeholder", "matchModeOptions", "maxConstraints", "minFractionDigits", "maxFractionDigits", "prefix", "suffix", "locale", "localeMatcher", "currency", "currencyDisplay", "useGrouping", "showButtons"] }, { kind: "component", type: i8.TriStateCheckbox, selector: "p-triStateCheckbox", inputs: ["disabled", "name", "ariaLabelledBy", "tabindex", "inputId", "style", "styleClass", "label", "readonly", "checkboxTrueIcon", "checkboxFalseIcon"], outputs: ["onChange"] }, { kind: "component", type: i9.RestWorldAvatarComponent, selector: "rw-avatar", inputs: ["user"] }, { kind: "component", type: i10.RestWorldInputComponent, selector: "rw-input", inputs: ["property", "apiName"] }, { kind: "component", type: i11.RestWorldMenuButtonComponent, selector: "rw-menu-button", inputs: ["items"] }, { kind: "pipe", type: i4.JsonPipe, name: "json" }, { kind: "pipe", type: i12.PropertyTypeFormatPipe, name: "propertyTypeFormat" }], viewProviders: [{
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.6", type: RestWorldTableComponent, selector: "rw-table", inputs: { apiName: "apiName", formArray: "formArray", searchTemplate: "searchTemplate", editTemplate: "editTemplate", rows: "rows", rowsPerPageOptions: "rowsPerPageOptions", headerMenu: "headerMenu", rowMenu: "rowMenu", showRowMenuAsColumn: "showRowMenuAsColumn", showRowMenuOnRightClick: "showRowMenuOnRightClick", rowStyleClass: "rowStyleClass", cellStyleClass: "cellStyleClass", totalRecords: "totalRecords", styleClass: "styleClass", tableStyle: "tableStyle", scrollable: "scrollable", scrollHeight: "scrollHeight", selectionMode: "selectionMode", rowHover: "rowHover", selection: "selection", isLoading: "isLoading" }, outputs: { onFilterOrSortChanged: "onFilterOrSortChanged", onRowSelect: "onRowSelect", onRowUnselect: "onRowUnselect", selectionChange: "selectionChange" }, viewQueries: [{ propertyName: "contextMenu", first: true, predicate: ["contextMenu"], descendants: true }], ngImport: i0, template: "<p-table\n  #table\n  [value]=\"rows\"\n  [columns]=\"columns\"\n  [lazy]=\"true\"\n  [lazyLoadOnInit]=\"false\"\n  (onLazyLoad)=\"load($event)\"\n  responsiveLayout=\"scroll\"\n  [paginator]=\"true\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [rows]=\"rows.length\"\n  [totalRecords]=\"totalRecords\"\n  [loading]=\"isLoading\"\n  sortMode=\"multiple\"\n  [multiSortMeta]=\"multiSortMeta\"\n  [styleClass]=\"styleClass\"\n  [tableStyle]=\"tableStyle\"\n  [scrollable]=\"scrollable\"\n  [scrollHeight]=\"scrollHeight\"\n  [selectionMode]=\"selectionMode\"\n  (onRowSelect)=\"onRowSelectInternal($event)\"\n  (onRowUnselect)=\"onRowUnselectInternal($event)\"\n  [rowHover]=\"rowHover\"\n  [(selection)]=\"_selection\"\n  (selectionChange)=\"onSelectionChangeInternal($event)\">\n\n  <ng-template pTemplate=\"header\" let-columns>\n    <tr>\n        <th *ngFor=\"let col of columns\" [pSortableColumn]=\"col.name\">\n            <div class=\"p-d-flex p-jc-between p-ai-center\">\n                {{col.prompt}}\n                <ng-container *ngIf=\"!col.readOnly\">\n                  <p-sortIcon [field]=\"col.name\"></p-sortIcon>\n                  <p-columnFilter [type]=\"toColumnFilterType(col.type)\" [matchMode]=\"toMatchMode(col.type)\" [field]=\"col.name\" display=\"menu\"></p-columnFilter>\n                </ng-container>\n            </div>\n        </th>\n        <th *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button [items]=\"headerMenu\"></rw-menu-button>\n        </th>\n    </tr>\n  </ng-template>\n\n  <ng-template pTemplate=\"body\" let-entity let-columns=\"columns\" let-rowIndex=\"rowIndex\">\n    <tr (contextmenu)=\"openContextMenu($event, entity)\" [pSelectableRow]=\"entity\" [pSelectableRowDisabled]=\"selectionMode === null\" [className]=\"rowStyleClasses[rowIndex - (table.first ?? 0)]\">\n      <td [ngSwitch]=\"col.type\" *ngFor=\"let col of columns\" [className]=\"cellStyleClasses[rowIndex - (table.first ?? 0)][col.name]\">\n          <ng-container *ngIf=\"showInputField(col); else textField\" [formGroup]=\"formArray!.controls[rowIndex - (table.first ?? 0)]\" >\n            <rw-input [apiName]=\"apiName!\" [property]=\"editProperties[col.name]\"></rw-input>\n          </ng-container>\n          <ng-template #textField>\n            <ng-container *ngSwitchCase=\"PropertyType.Text\">\n                <rw-avatar *ngIf=\"col.name === 'createdBy' || col.name === 'lastChangedBy'\" [user]=\"entity[col.name]\"></rw-avatar>\n                <span *ngIf=\"col.name !== 'createdBy' && col.name !== 'lastChangedBy'\">{{entity[col.name]}}</span>\n            </ng-container>\n            <span *ngSwitchCase=\"PropertyType.Number\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Percent\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Currency\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Bool\" class=\"flex justify-content-center\"><p-triStateCheckbox [(ngModel)]=\"entity[col.name]\" [readonly]=\"true\"></p-triStateCheckbox></span>\n            <span *ngSwitchCase=\"PropertyType.Date\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Time\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Duration\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeLocal\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeOffset\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.Collection\" class=\"flex justify-content-end\"><p *ngFor=\"let arrayElement of entity[col.name]\">{{arrayElement | json}}</p></span>\n            <span *ngSwitchCase=\"PropertyType.Object\" class=\"flex justify-content-end\">{{entity[col.name] | json}}</span>\n            <span *ngSwitchDefault [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n          </ng-template>\n        </td>\n        <td *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button *ngIf=\"showRowMenuAsColumn\" [items]=\"rowMenus[rowIndex - (table.first ?? 0)]\"></rw-menu-button>\n        </td>\n    </tr>\n  </ng-template>\n\n  <p-contextMenu #contextMenu appendTo=\"body\" [model]=\"contextMenuItems\"></p-contextMenu>\n</p-table>\n", styles: [".p-tooltip{max-width:-moz-fit-content;max-width:fit-content}a.p-button{text-decoration:none}\n"], dependencies: [{ kind: "directive", type: i3.PrimeTemplate, selector: "[pTemplate]", inputs: ["type", "pTemplate"] }, { kind: "directive", type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i4.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i4.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i4.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "component", type: i5.ContextMenu, selector: "p-contextMenu", inputs: ["model", "triggerEvent", "target", "global", "style", "styleClass", "appendTo", "autoZIndex", "baseZIndex", "id", "ariaLabel", "ariaLabelledBy"], outputs: ["onShow", "onHide"] }, { kind: "directive", type: i6.Tooltip, selector: "[pTooltip]", inputs: ["tooltipPosition", "tooltipEvent", "appendTo", "positionStyle", "tooltipStyleClass", "tooltipZIndex", "escape", "showDelay", "hideDelay", "life", "positionTop", "positionLeft", "autoHide", "fitContent", "hideOnEscape", "pTooltip", "tooltipDisabled", "tooltipOptions"] }, { kind: "directive", type: i1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i7.Table, selector: "p-table", inputs: ["frozenColumns", "frozenValue", "style", "styleClass", "tableStyle", "tableStyleClass", "paginator", "pageLinks", "rowsPerPageOptions", "alwaysShowPaginator", "paginatorPosition", "paginatorStyleClass", "paginatorDropdownAppendTo", "paginatorDropdownScrollHeight", "currentPageReportTemplate", "showCurrentPageReport", "showJumpToPageDropdown", "showJumpToPageInput", "showFirstLastIcon", "showPageLinks", "defaultSortOrder", "sortMode", "resetPageOnSort", "selectionMode", "selectionPageOnly", "contextMenuSelection", "contextMenuSelectionMode", "dataKey", "metaKeySelection", "rowSelectable", "rowTrackBy", "lazy", "lazyLoadOnInit", "compareSelectionBy", "csvSeparator", "exportFilename", "filters", "globalFilterFields", "filterDelay", "filterLocale", "expandedRowKeys", "editingRowKeys", "rowExpandMode", "scrollable", "scrollDirection", "rowGroupMode", "scrollHeight", "virtualScroll", "virtualScrollItemSize", "virtualScrollOptions", "virtualScrollDelay", "frozenWidth", "responsive", "contextMenu", "resizableColumns", "columnResizeMode", "reorderableColumns", "loading", "loadingIcon", "showLoader", "rowHover", "customSort", "showInitialSortBadge", "autoLayout", "exportFunction", "exportHeader", "stateKey", "stateStorage", "editMode", "groupRowsBy", "groupRowsByOrder", "responsiveLayout", "breakpoint", "paginatorLocale", "value", "columns", "first", "rows", "totalRecords", "sortField", "sortOrder", "multiSortMeta", "selection", "selectAll", "virtualRowHeight"], outputs: ["contextMenuSelectionChange", "selectAllChange", "selectionChange", "onRowSelect", "onRowUnselect", "onPage", "onSort", "onFilter", "onLazyLoad", "onRowExpand", "onRowCollapse", "onContextMenuSelect", "onColResize", "onColReorder", "onRowReorder", "onEditInit", "onEditComplete", "onEditCancel", "onHeaderCheckboxToggle", "sortFunction", "firstChange", "rowsChange", "onStateSave", "onStateRestore"] }, { kind: "directive", type: i7.SortableColumn, selector: "[pSortableColumn]", inputs: ["pSortableColumn", "pSortableColumnDisabled"] }, { kind: "directive", type: i7.SelectableRow, selector: "[pSelectableRow]", inputs: ["pSelectableRow", "pSelectableRowIndex", "pSelectableRowDisabled"] }, { kind: "component", type: i7.SortIcon, selector: "p-sortIcon", inputs: ["field"] }, { kind: "component", type: i7.ColumnFilter, selector: "p-columnFilter", inputs: ["field", "type", "display", "showMenu", "matchMode", "operator", "showOperator", "showClearButton", "showApplyButton", "showMatchModes", "showAddButton", "hideOnClear", "placeholder", "matchModeOptions", "maxConstraints", "minFractionDigits", "maxFractionDigits", "prefix", "suffix", "locale", "localeMatcher", "currency", "currencyDisplay", "useGrouping", "showButtons"] }, { kind: "component", type: i8.TriStateCheckbox, selector: "p-triStateCheckbox", inputs: ["disabled", "name", "ariaLabelledBy", "tabindex", "inputId", "style", "styleClass", "label", "readonly", "checkboxTrueIcon", "checkboxFalseIcon"], outputs: ["onChange"] }, { kind: "component", type: i9.RestWorldAvatarComponent, selector: "rw-avatar", inputs: ["user"] }, { kind: "component", type: i10.RestWorldInputComponent, selector: "rw-input", inputs: ["property", "apiName"] }, { kind: "component", type: i11.RestWorldMenuButtonComponent, selector: "rw-menu-button", inputs: ["items"] }, { kind: "pipe", type: i4.JsonPipe, name: "json" }, { kind: "pipe", type: i12.PropertyTypeFormatPipe, name: "propertyTypeFormat" }], viewProviders: [{
                 provide: ControlContainer,
                 deps: [[Optional, FormArrayName]],
                 useFactory: (arrayName) => arrayName,
@@ -413,7 +422,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImpor
                             provide: ControlContainer,
                             deps: [[Optional, FormArrayName]],
                             useFactory: (arrayName) => arrayName,
-                        }], template: "<p-table\n  #table\n  [value]=\"rows\"\n  [columns]=\"columns\"\n  [lazy]=\"true\"\n  [lazyLoadOnInit]=\"false\"\n  (onLazyLoad)=\"load($event)\"\n  responsiveLayout=\"scroll\"\n  [paginator]=\"true\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [rows]=\"rows.length\"\n  [totalRecords]=\"totalRecords\"\n  [loading]=\"isLoading\"\n  sortMode=\"multiple\"\n  [multiSortMeta]=\"multiSortMeta\"\n  [styleClass]=\"styleClass\"\n  [tableStyle]=\"tableStyle\"\n  [scrollable]=\"scrollable\"\n  [scrollHeight]=\"scrollHeight\"\n  [selectionMode]=\"selectionMode\"\n  (onRowSelect)=\"onRowSelectInternal($event)\"\n  (onRowUnselect)=\"onRowUnselectInternal($event)\"\n  [rowHover]=\"rowHover\"\n  [(selection)]=\"_selection\"\n  (selectionChange)=\"onSelectionChangeInternal($event)\">\n\n  <ng-template pTemplate=\"header\" let-columns>\n    <tr>\n        <th *ngFor=\"let col of columns\" [pSortableColumn]=\"col.name\">\n            <div class=\"p-d-flex p-jc-between p-ai-center\">\n                {{col.prompt}}\n                <ng-container *ngIf=\"!col.readOnly\">\n                  <p-sortIcon [field]=\"col.name\"></p-sortIcon>\n                  <p-columnFilter [type]=\"toColumnFilterType(col.type)\" [field]=\"col.name\" display=\"menu\"></p-columnFilter>\n                </ng-container>\n            </div>\n        </th>\n        <th *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button [items]=\"headerMenu\"></rw-menu-button>\n        </th>\n    </tr>\n  </ng-template>\n\n  <ng-template pTemplate=\"body\" let-entity let-columns=\"columns\" let-rowIndex=\"rowIndex\">\n    <tr (contextmenu)=\"openContextMenu($event, entity)\" [pSelectableRow]=\"entity\" [pSelectableRowDisabled]=\"selectionMode === null\" [className]=\"rowStyleClasses[rowIndex - (table.first ?? 0)]\">\n      <td [ngSwitch]=\"col.type\" *ngFor=\"let col of columns\" [className]=\"cellStyleClasses[rowIndex - (table.first ?? 0)][col.name]\">\n          <ng-container *ngIf=\"showInputField(col); else textField\" [formGroup]=\"formArray!.controls[rowIndex - (table.first ?? 0)]\" >\n            <rw-input [apiName]=\"apiName!\" [property]=\"editProperties[col.name]\"></rw-input>\n          </ng-container>\n          <ng-template #textField>\n            <ng-container *ngSwitchCase=\"PropertyType.Text\">\n                <rw-avatar *ngIf=\"col.name === 'createdBy' || col.name === 'lastChangedBy'\" [user]=\"entity[col.name]\"></rw-avatar>\n                <span *ngIf=\"col.name !== 'createdBy' && col.name !== 'lastChangedBy'\">{{entity[col.name]}}</span>\n            </ng-container>\n            <span *ngSwitchCase=\"PropertyType.Number\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Percent\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Currency\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Bool\" class=\"flex justify-content-center\"><p-triStateCheckbox [(ngModel)]=\"entity[col.name]\" [readonly]=\"true\"></p-triStateCheckbox></span>\n            <span *ngSwitchCase=\"PropertyType.Date\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Time\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Duration\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeLocal\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeOffset\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.Collection\" class=\"flex justify-content-end\"><p *ngFor=\"let arrayElement of entity[col.name]\">{{arrayElement | json}}</p></span>\n            <span *ngSwitchCase=\"PropertyType.Object\" class=\"flex justify-content-end\">{{entity[col.name] | json}}</span>\n            <span *ngSwitchDefault [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n          </ng-template>\n        </td>\n        <td *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button *ngIf=\"showRowMenuAsColumn\" [items]=\"rowMenus[rowIndex - (table.first ?? 0)]\"></rw-menu-button>\n        </td>\n    </tr>\n  </ng-template>\n\n  <p-contextMenu #contextMenu appendTo=\"body\" [model]=\"contextMenuItems\"></p-contextMenu>\n</p-table>\n", styles: [".p-tooltip{max-width:-moz-fit-content;max-width:fit-content}a.p-button{text-decoration:none}\n"] }]
+                        }], template: "<p-table\n  #table\n  [value]=\"rows\"\n  [columns]=\"columns\"\n  [lazy]=\"true\"\n  [lazyLoadOnInit]=\"false\"\n  (onLazyLoad)=\"load($event)\"\n  responsiveLayout=\"scroll\"\n  [paginator]=\"true\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [rows]=\"rows.length\"\n  [totalRecords]=\"totalRecords\"\n  [loading]=\"isLoading\"\n  sortMode=\"multiple\"\n  [multiSortMeta]=\"multiSortMeta\"\n  [styleClass]=\"styleClass\"\n  [tableStyle]=\"tableStyle\"\n  [scrollable]=\"scrollable\"\n  [scrollHeight]=\"scrollHeight\"\n  [selectionMode]=\"selectionMode\"\n  (onRowSelect)=\"onRowSelectInternal($event)\"\n  (onRowUnselect)=\"onRowUnselectInternal($event)\"\n  [rowHover]=\"rowHover\"\n  [(selection)]=\"_selection\"\n  (selectionChange)=\"onSelectionChangeInternal($event)\">\n\n  <ng-template pTemplate=\"header\" let-columns>\n    <tr>\n        <th *ngFor=\"let col of columns\" [pSortableColumn]=\"col.name\">\n            <div class=\"p-d-flex p-jc-between p-ai-center\">\n                {{col.prompt}}\n                <ng-container *ngIf=\"!col.readOnly\">\n                  <p-sortIcon [field]=\"col.name\"></p-sortIcon>\n                  <p-columnFilter [type]=\"toColumnFilterType(col.type)\" [matchMode]=\"toMatchMode(col.type)\" [field]=\"col.name\" display=\"menu\"></p-columnFilter>\n                </ng-container>\n            </div>\n        </th>\n        <th *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button [items]=\"headerMenu\"></rw-menu-button>\n        </th>\n    </tr>\n  </ng-template>\n\n  <ng-template pTemplate=\"body\" let-entity let-columns=\"columns\" let-rowIndex=\"rowIndex\">\n    <tr (contextmenu)=\"openContextMenu($event, entity)\" [pSelectableRow]=\"entity\" [pSelectableRowDisabled]=\"selectionMode === null\" [className]=\"rowStyleClasses[rowIndex - (table.first ?? 0)]\">\n      <td [ngSwitch]=\"col.type\" *ngFor=\"let col of columns\" [className]=\"cellStyleClasses[rowIndex - (table.first ?? 0)][col.name]\">\n          <ng-container *ngIf=\"showInputField(col); else textField\" [formGroup]=\"formArray!.controls[rowIndex - (table.first ?? 0)]\" >\n            <rw-input [apiName]=\"apiName!\" [property]=\"editProperties[col.name]\"></rw-input>\n          </ng-container>\n          <ng-template #textField>\n            <ng-container *ngSwitchCase=\"PropertyType.Text\">\n                <rw-avatar *ngIf=\"col.name === 'createdBy' || col.name === 'lastChangedBy'\" [user]=\"entity[col.name]\"></rw-avatar>\n                <span *ngIf=\"col.name !== 'createdBy' && col.name !== 'lastChangedBy'\">{{entity[col.name]}}</span>\n            </ng-container>\n            <span *ngSwitchCase=\"PropertyType.Number\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Percent\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Currency\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Bool\" class=\"flex justify-content-center\"><p-triStateCheckbox [(ngModel)]=\"entity[col.name]\" [readonly]=\"true\"></p-triStateCheckbox></span>\n            <span *ngSwitchCase=\"PropertyType.Date\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Time\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Duration\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeLocal\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeOffset\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.Collection\" class=\"flex justify-content-end\"><p *ngFor=\"let arrayElement of entity[col.name]\">{{arrayElement | json}}</p></span>\n            <span *ngSwitchCase=\"PropertyType.Object\" class=\"flex justify-content-end\">{{entity[col.name] | json}}</span>\n            <span *ngSwitchDefault [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n          </ng-template>\n        </td>\n        <td *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button *ngIf=\"showRowMenuAsColumn\" [items]=\"rowMenus[rowIndex - (table.first ?? 0)]\"></rw-menu-button>\n        </td>\n    </tr>\n  </ng-template>\n\n  <p-contextMenu #contextMenu appendTo=\"body\" [model]=\"contextMenuItems\"></p-contextMenu>\n</p-table>\n", styles: [".p-tooltip{max-width:-moz-fit-content;max-width:fit-content}a.p-button{text-decoration:none}\n"] }]
         }], ctorParameters: function () { return [{ type: i1.ControlContainer }, { type: i2.FormService }]; }, propDecorators: { apiName: [{
                 type: Input
             }], formArray: [{
@@ -470,4 +479,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.6", ngImpor
             }], isLoading: [{
                 type: Input
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restworld-table.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-table/restworld-table.component.ts","../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-table/restworld-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, Optional, Output, ViewChild } from '@angular/core';\nimport { FormService, Property, PropertyType, SimpleValue, Template } from '@wertzui/ngx-hal-client';\nimport * as _ from 'lodash';\nimport { MenuItem, SortMeta } from 'primeng/api';\nimport { ODataParameters } from '../../models/o-data';\nimport { ODataService } from '../../services/o-data.service';\nimport { ContextMenu } from 'primeng/contextmenu';\nimport { AbstractControl, ControlContainer, FormArray, FormArrayName, FormGroup } from '@angular/forms';\nimport { TableLazyLoadEvent, TableRowSelectEvent, TableRowUnSelectEvent } from 'primeng/table';\n\nenum ColumnFilterType {\n  text = 'text',\n  numeric = 'numeric',\n  boolean = 'boolean',\n  date = 'date'\n}\n\n/**\n * Displays a table based on a search-, an edit-template and a list of items.\n * The search-template is required and used to display the table columns and to filter and sort the items.\n * The edit-template is optional and used to edit the items. For the edit capability, the table must be part of a reactive form.\n * The items are displayed as table rows.\n * The table supports lazy loading, row selection, row menus, and context menus.\n * \n * @example\n * <rw-table\n *   [apiName]=\"apiName\"\n *   [searchTemplate]=\"searchTemplate\"\n *   [editTemplate]=\"editTemplate\"\n *   [rows]=\"rows\"\n *   [rowsPerPageOptions]=\"[10, 25, 50]\"\n *   [headerMenu]=\"headerMenu\"\n *   [rowMenu]=\"rowMenu\"\n *   [rowStyleClass]=\"rowStyleClass\"\n *   [cellStyleClass]=\"cellStyleClass\"\n *   [totalRecords]=\"totalRecords\"\n *   [multiSortMeta]=\"multiSortMeta\"\n *   [styleClass]=\"styleClass\"\n *   [tableStyle]=\"tableStyle\"\n *   [scrollable]=\"scrollable\"\n *   [scrollHeight]=\"scrollHeight\"\n *   [selectionMode]=\"selectionMode\"\n *   [rowHover]=\"rowHover\"\n *   [selection]=\"selection\"\n *   [contextMenuItems]=\"contextMenuItems\"\n *   [isLoading]=\"isLoading\"\n *   (onFilterOrSortChanged)=\"onFilterOrSortChanged($event)\"\n *   (onRowSelect)=\"onRowSelect($event)\"\n *   (onRowUnselect)=\"onRowUnselect($event)\"\n *   (selectionChange)=\"selectionChange($event)\">\n * </rw-table>\n * \n */\n@Component({\n  selector: 'rw-table',\n  templateUrl: './restworld-table.component.html',\n  styleUrls: ['./restworld-table.component.css'],\n  viewProviders: [{\n    provide: ControlContainer,\n    deps: [[Optional, FormArrayName]],\n    useFactory: (arrayName: FormArrayName) => arrayName, }]\n  })\nexport class RestWorldTableComponent<TListItem extends Record<string, any>> {\n  /**\n   * The name of the api.\n   * For the editing capability, you must also set the editTemplate and the formArray.\n   */\n  @Input()\n  public apiName?: string;\n\n  private _formArray?: FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>>;\n\n  /**\n   * The form array that contains the form groups for the items.\n   * Bind this to the form array that contains the form groups for the items.\n   * Each entry in the array represents one row in the currently displayed page of the table.\n   * For the editing capability, you must also set the apiName and the editTemplate.\n   */\n  @Input()\n  public set formArray(value: FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>> | undefined) {\n    this._formArray = value;\n  }\n\n  public get formArray(): FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>> | undefined {\n    return this._formArray ?? this._controlContainer?.control as FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>> | undefined;\n  }\n\n  private _searchTemplate: Template = new Template({properties: []});\n\n  /**\n   * The template that is used to display the table columns and to filter and sort the items.\n   * Bind this to the template that is used to display the table columns and to filter and sort the items.\n   * Normally this is returned from the backend as part of the hal-forms resource from a list endpoint.\n   */\n  @Input({ required: true })\n  public set searchTemplate(value: Template){\n    this._searchTemplate = value;\n    this._columns = value?.properties.filter(p => p.type !== PropertyType.Hidden) ?? [];\n    this.setSortFieldAndSortOrder(value)\n  }\n\n  public get searchTemplate() {\n    return this._searchTemplate;\n  }\n\n  private _editTemplate?: Template;\n\n  /**\n   * The template that is used to edit the items.\n   * Bind this to the template that is used to edit the items.\n   * Normally this is returned from the backend as part of the hal-forms resource from a list endpoint.\n   * For the editing capability, you must also set the apiName and the formArray.\n   */\n  @Input()\n  public set editTemplate(value: Template | undefined){\n    this._editTemplate = value;\n    this.updateEditProperties();\n    this.updateFormArray();\n  }\n\n  public get editTemplate() {\n    return this._editTemplate;\n  }\n\n  private _editProperties: Record<string, Property<SimpleValue, string, string>> = {};\n  public get editProperties() {\n    return this._editProperties;\n  }\n\n  public get isEditable() {\n    return this.editTemplate !== undefined && this.formArray !== undefined && this.apiName;\n  }\n\n  private _rows: TListItem[] = [];\n  public get rows() {\n    return this._rows;\n  }\n\n  /**\n   * The items that are displayed as table rows.\n   * Bind this to the items that are displayed as table rows.\n   * Normally this is returned from the backend as part of the hal-forms resource from a list endpoint.\n   */\n  @Input({ required: true })\n  public set rows(value: TListItem[]) {\n    this._rows = value;\n    this.updateCalculatedFunctionValues(value);\n    this.updateFormArray();\n  }\n\n  /**\n   * The possible values for the number of rows per page.\n   * The default is [10, 25, 50].\n   */\n  @Input()\n  public rowsPerPageOptions = [10, 25, 50];\n\n  /**\n   * An optional menu that is displayed at the top right of the table.\n   * @see RestWorldMenuButtonComponent\n   */\n  @Input()\n  public headerMenu: MenuItem[] = [];\n\n  private _rowMenu: (row: TListItem, openedByRightClick: boolean) => MenuItem[] = () => [];\n  public get rowMenu(): (row: TListItem, openedByRightClick: boolean) => MenuItem[] {\n    return this._rowMenu;\n  }\n\n  /**\n   * A function that returns the menu for a row.\n   * Based on the openedByRightClick parameter, the function can return different menus.\n   * The menu when it has not been opened by a right click is displayed in an extra column to the right of the table if `showRowMenuAsColumn` is `true`.\n   * The menu when it has been opened by a right click is displayed as a context menu if `showRowMenuOnRightClick` is `true`.\n   * @param row The row for which to return the menu.\n   * @param openedByRightClick Indicates whether the menu was opened by a right click.\n   * @returns The menu for the row.\n   * @see showRowMenuAsColumn\n   * @see showRowMenuOnRightClick\n   */\n  @Input()\n  public set rowMenu(value: (row: TListItem, openedByRightClick: boolean) => MenuItem[]) {\n    this._rowMenu = value;\n    this.updateRowMenus(this.rows);\n  }\n\n  private _rowMenus: MenuItem[][] = [];\n\n  private updateCalculatedFunctionValues(value: TListItem[]) {\n    this.updateRowMenus(value);\n    this.updateRowStyles(value);\n    this.updateCellStyles(value);\n  }\n\n  private updateCellStyles(value: TListItem[]) {\n    this._cellStyleClasses = value.map((r, ri) => Object.fromEntries(this.columns.map((c, ci) => [c.name, this.cellStyleClass(r, c, ri, ci)])));\n  }\n\n  private updateRowStyles(value: TListItem[]) {\n    this._rowStyleClasses = value.map((r, i) => this.rowStyleClass(r, i));\n  }\n\n  private updateRowMenus(value: TListItem[]) {\n    if (this.showRowMenuAsColumn)\n      this._rowMenus = value.map(r => this.rowMenu(r, false));\n  }\n\n  public get rowMenus() {\n    return this._rowMenus;\n  }\n\n  public get showMenuColumn() {\n    return this.headerMenu.length > 0 || (this.showRowMenuAsColumn && this.rowMenus.some(m => m.length > 0));\n  }\n\n  /**\n   * Indicates whether the row menu is displayed as a column to the right of the table.\n   */\n  @Input()\n  public showRowMenuAsColumn = true;\n\n  /**\n   * Indicates whether the row menu is displayed as a context menu when the user right clicks on a row.\n   */\n  @Input()\n  public showRowMenuOnRightClick = true;\n\n  private _rowStyleClass: (row: TListItem, rowIndex: number) => string = () => \"\";\n  public get rowStyleClass(): (row: TListItem, rowIndex: number) => string {\n    return this._rowStyleClass;\n  }\n\n  /**\n   * A function that returns the style class for a row.\n   * @param row The row for which to return the style class.\n   * @param rowIndex The index of the row on the currently displayed page.\n   * @returns The style class for the row.\n   */\n  @Input()\n  public set rowStyleClass(value: (row: TListItem, rowIndex: number) => string) {\n    this._rowStyleClass = value;\n    this.updateRowStyles(this.rows);\n  }\n\n  private _rowStyleClasses: string[] = [];\n  public get rowStyleClasses() {\n    return this._rowStyleClasses;\n  }\n\n  private _cellStyleClass: (row: TListItem, column: Property<SimpleValue, string, string>, rowIndex: number, columnIndex: number) => string = () => \"\";\n  public get cellStyleClass(): (row: TListItem, column: Property<SimpleValue, string, string>, rowIndex: number, columnIndex: number) => string {\n    return this._cellStyleClass;\n  }\n  /**\n   * A function that returns the style class for a cell.\n   * @param row The row for which to return the style class.\n   * @param column The column for which to return the style class.\n   * @param rowIndex The index of the row on the currently displayed page.\n   * @param columnIndex The index of the column.\n   * @returns The style class for the cell.\n   */\n  @Input()\n  public set cellStyleClass(value: (row: TListItem, column: Property<SimpleValue, string, string>, rowIndex: number, columnIndex: number) => string) {\n    this._cellStyleClass = value;\n    this.updateCellStyles(this.rows);\n  }\n\n  private _cellStyleClasses: Record<string,string>[] = [];\n  public get cellStyleClasses() {\n    return this._cellStyleClasses;\n  }\n\n  @Input()\n  public totalRecords = 0;\n\n  public constructor(\n    private readonly _controlContainer: ControlContainer,\n    private readonly _formService: FormService,) {\n  }\n\n  private setSortFieldAndSortOrder(template: Template | undefined) {\n    const orderBy = template?.properties?.find(p => p?.name === \"$orderby\")?.value;\n\n    if(orderBy === null || orderBy === undefined || typeof orderBy !== 'string')\n    return;\n\n    const [field, order] = orderBy.split(\" \");\n    const orderAsNumber = order?.toLowerCase() === \"desc\" ? -1 : 1;\n\n    if (this.multiSortMeta?.length !== 1 || this.multiSortMeta[0].field !== field || this.multiSortMeta[0].order !== orderAsNumber)\n      this.multiSortMeta = [{field: field, order: orderAsNumber}]\n  }\n\n  public multiSortMeta?: SortMeta[] | null;\n\n  /**\n   * The style class for the table.\n   * The default is \"\".\n   */\n  @Input()\n  public styleClass: string = \"\";\n\n  /**\n   * The inline style for the table.\n   */\n  @Input()\n  public tableStyle?: Record<string,string>;\n\n  /**\n   * Indicates whether the table is scrollable.\n   * The default is `true`.\n   */\n  @Input()\n  public scrollable: boolean = true;\n\n  /**\n   * The height of the scrollable table.\n   * The default is \"flex\".\n   */\n  @Input()\n  public scrollHeight: string = \"flex\";\n\n  /**\n   * Emitted when the filter or sort parameters have changed.\n   * Subscribe to this event to load the items from the backend.\n   * This is one of the core features of the table.\n   */\n  @Output()\n  public onFilterOrSortChanged = new EventEmitter<ODataParameters>();\n\n  /**\n   * Emitted when a row has been selected.\n   */\n  @Output()\n  public onRowSelect = new EventEmitter<TListItem>();\n\n  /**\n   * Emitted when a row has been unselected.\n   */\n  @Output()\n  public onRowUnselect = new EventEmitter<TListItem>();\n\n  /**\n   * The mode how rows can be selected.\n   * The default is `null` which means rows cannot be selected.\n   */\n  @Input()\n  public selectionMode: \"single\" | \"multiple\" | null = null;\n\n  /**\n   * Indicates whether the table rows are highlighted when the mouse hovers over them.\n   */\n  @Input()\n  public rowHover: boolean = false;\n\n  /**\n   * The currently selected rows.\n   */\n  @Input()\n  public get selection(): TListItem[] {\n    return _.isArray(this._selection) ? this._selection : [this._selection];\n  }\n  public set selection(value: TListItem[]) {\n    this._selection = value;\n  }\n  public _selection: TListItem | TListItem[] = [];\n\n  /**\n   * Emitted when the selection has changed.\n   * @param event The new selection.\n   */\n  @Output()\n  selectionChange: EventEmitter<TListItem[]> = new EventEmitter();\n\n  @ViewChild(\"contextMenu\")\n  contextMenu?: ContextMenu;\n\n  private _contextMenuItems: MenuItem[] = [];\n  public get contextMenuItems() {\n    return this._contextMenuItems;\n  }\n\n  /**\n   * Indicates whether the table is currently loading.\n   * Set this to true while loading new items from the backend when reacting to the `onFilterOrSortChanged` event.\n   */\n  @Input()\n  public isLoading = false;\n\n  private _columns: Property<SimpleValue, string, string>[] = [];\n  public get columns(): Property<SimpleValue, string, string>[] {\n    return this._columns;\n  }\n\n  private _rowsBeforeCurrentPage: number = 0;\n  public get rowsBeforeCurrentPage(): number {\n    return this._rowsBeforeCurrentPage;\n  }\n\n  private static readonly _dateFormat = new Date(3333, 10, 22) // months start at 0 in JS\n    .toLocaleDateString()\n    .replace(\"22\", \"dd\")\n    .replace(\"11\", \"MM\")\n    .replace(\"3333\", \"yy\")\n    .replace(\"33\", \"y\");\n\n  public get dateFormat(): string {\n    return RestWorldTableComponent._dateFormat;\n  }\n\n  private static readonly _timeFormat = new Date(1, 1, 1, 22, 33, 44)\n    .toLocaleTimeString()\n    .replace(\"22\", \"hh\")\n    .replace(\"33\", \"mm\")\n    .replace(\"44\", \"ss\");\n\n  public get timeFormat() {\n    return RestWorldTableComponent._timeFormat;\n  }\n\n  public get PropertyType(): typeof PropertyType {\n    return PropertyType;\n  }\n\n  public load(event: TableLazyLoadEvent) {\n    this.multiSortMeta = event.multiSortMeta;\n    this._rowsBeforeCurrentPage = event.first ?? 0;\n    const parameters = ODataService.createParametersFromTableLoadEvent(event, this.searchTemplate);\n    this.onFilterOrSortChanged.emit(parameters);\n  }\n\n  public openContextMenu(event: MouseEvent, row: TListItem): void {\n    if (!this.showRowMenuOnRightClick || this.contextMenu === undefined)\n      return;\n\n    this._contextMenuItems = this.rowMenu(row, true);\n    this.contextMenu.show(event);\n    event.stopPropagation();\n  }\n\n  public onRowSelectInternal(event: TableRowSelectEvent): void {\n    this.onRowSelect.emit(event.data);\n  }\n\n  public onRowUnselectInternal(event: TableRowUnSelectEvent): void {\n    this.onRowUnselect.emit(event.data);\n  }\n\n  public onSelectionChangeInternal(event: TListItem | TListItem[]): void {\n    this.selectionChange.emit(_.isArray(event) ? event : [event]);\n  }\n\n  public toColumnFilterType(propertyType: PropertyType) : ColumnFilterType{\n    switch(propertyType) {\n      case PropertyType.Number:\n      case PropertyType.Percent:\n      case PropertyType.Currency:\n      case PropertyType.Month:\n        return ColumnFilterType.numeric;\n      case PropertyType.Bool:\n        return ColumnFilterType.boolean;\n      case PropertyType.Date:\n      case PropertyType.DatetimeLocal:\n      case PropertyType.DatetimeOffset:\n        return ColumnFilterType.date;\n      default:\n        return ColumnFilterType.text;\n    }\n  }\n\n  public showInputField(column: Property): boolean {\n    if (!this.isEditable)\n      return false;\n\n    const editProperty = this.editProperties[column.name];\n\n    return editProperty !== undefined && editProperty.type !== PropertyType.Hidden && !editProperty.readOnly;\n  }\n\n  private updateFormArray(): void {\n    if(!this.isEditable || !this.rows || !this.formArray || !this.editTemplate)\n      return;\n\n    this.formArray.clear();\n\n    const newControls = this.rows\n      .map(r => {\n        const formGroup = this._formService.createFormGroupFromTemplate(this.editTemplate!) as FormGroup;\n        formGroup.patchValue(r);\n        return formGroup;\n      });\n\n    for (const control of newControls)\n      this.formArray.push(control);\n  }\n\n  private updateEditProperties(): void {\n    if (!this.editTemplate)\n      return;\n\n    this._editProperties = Object.fromEntries(this.editTemplate.properties.map(p => [ p.name, p ]));\n  }\n}\n","<p-table\n  #table\n  [value]=\"rows\"\n  [columns]=\"columns\"\n  [lazy]=\"true\"\n  [lazyLoadOnInit]=\"false\"\n  (onLazyLoad)=\"load($event)\"\n  responsiveLayout=\"scroll\"\n  [paginator]=\"true\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [rows]=\"rows.length\"\n  [totalRecords]=\"totalRecords\"\n  [loading]=\"isLoading\"\n  sortMode=\"multiple\"\n  [multiSortMeta]=\"multiSortMeta\"\n  [styleClass]=\"styleClass\"\n  [tableStyle]=\"tableStyle\"\n  [scrollable]=\"scrollable\"\n  [scrollHeight]=\"scrollHeight\"\n  [selectionMode]=\"selectionMode\"\n  (onRowSelect)=\"onRowSelectInternal($event)\"\n  (onRowUnselect)=\"onRowUnselectInternal($event)\"\n  [rowHover]=\"rowHover\"\n  [(selection)]=\"_selection\"\n  (selectionChange)=\"onSelectionChangeInternal($event)\">\n\n  <ng-template pTemplate=\"header\" let-columns>\n    <tr>\n        <th *ngFor=\"let col of columns\" [pSortableColumn]=\"col.name\">\n            <div class=\"p-d-flex p-jc-between p-ai-center\">\n                {{col.prompt}}\n                <ng-container *ngIf=\"!col.readOnly\">\n                  <p-sortIcon [field]=\"col.name\"></p-sortIcon>\n                  <p-columnFilter [type]=\"toColumnFilterType(col.type)\" [field]=\"col.name\" display=\"menu\"></p-columnFilter>\n                </ng-container>\n            </div>\n        </th>\n        <th *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button [items]=\"headerMenu\"></rw-menu-button>\n        </th>\n    </tr>\n  </ng-template>\n\n  <ng-template pTemplate=\"body\" let-entity let-columns=\"columns\" let-rowIndex=\"rowIndex\">\n    <tr (contextmenu)=\"openContextMenu($event, entity)\" [pSelectableRow]=\"entity\" [pSelectableRowDisabled]=\"selectionMode === null\" [className]=\"rowStyleClasses[rowIndex - (table.first ?? 0)]\">\n      <td [ngSwitch]=\"col.type\" *ngFor=\"let col of columns\" [className]=\"cellStyleClasses[rowIndex - (table.first ?? 0)][col.name]\">\n          <ng-container *ngIf=\"showInputField(col); else textField\" [formGroup]=\"formArray!.controls[rowIndex - (table.first ?? 0)]\" >\n            <rw-input [apiName]=\"apiName!\" [property]=\"editProperties[col.name]\"></rw-input>\n          </ng-container>\n          <ng-template #textField>\n            <ng-container *ngSwitchCase=\"PropertyType.Text\">\n                <rw-avatar *ngIf=\"col.name === 'createdBy' || col.name === 'lastChangedBy'\" [user]=\"entity[col.name]\"></rw-avatar>\n                <span *ngIf=\"col.name !== 'createdBy' && col.name !== 'lastChangedBy'\">{{entity[col.name]}}</span>\n            </ng-container>\n            <span *ngSwitchCase=\"PropertyType.Number\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Percent\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Currency\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Bool\" class=\"flex justify-content-center\"><p-triStateCheckbox [(ngModel)]=\"entity[col.name]\" [readonly]=\"true\"></p-triStateCheckbox></span>\n            <span *ngSwitchCase=\"PropertyType.Date\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Time\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Duration\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeLocal\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeOffset\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.Collection\" class=\"flex justify-content-end\"><p *ngFor=\"let arrayElement of entity[col.name]\">{{arrayElement | json}}</p></span>\n            <span *ngSwitchCase=\"PropertyType.Object\" class=\"flex justify-content-end\">{{entity[col.name] | json}}</span>\n            <span *ngSwitchDefault [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n          </ng-template>\n        </td>\n        <td *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button *ngIf=\"showRowMenuAsColumn\" [items]=\"rowMenus[rowIndex - (table.first ?? 0)]\"></rw-menu-button>\n        </td>\n    </tr>\n  </ng-template>\n\n  <p-contextMenu #contextMenu appendTo=\"body\" [model]=\"contextMenuItems\"></p-contextMenu>\n</p-table>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"restworld-table.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-table/restworld-table.component.ts","../../../../../../projects/ngx-restworld-client/src/lib/components/restworld-table/restworld-table.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, Optional, Output, ViewChild } from '@angular/core';\nimport { FormService, Property, PropertyType, SimpleValue, Template } from '@wertzui/ngx-hal-client';\nimport * as _ from 'lodash';\nimport { FilterMatchMode, MenuItem, SortMeta } from 'primeng/api';\nimport { ODataParameters } from '../../models/o-data';\nimport { ODataService } from '../../services/o-data.service';\nimport { ContextMenu } from 'primeng/contextmenu';\nimport { AbstractControl, ControlContainer, FormArray, FormArrayName, FormGroup } from '@angular/forms';\nimport { TableLazyLoadEvent, TableRowSelectEvent, TableRowUnSelectEvent } from 'primeng/table';\n\nenum ColumnFilterType {\n  text = 'text',\n  numeric = 'numeric',\n  boolean = 'boolean',\n  date = 'date'\n}\n\n/**\n * Displays a table based on a search-, an edit-template and a list of items.\n * The search-template is required and used to display the table columns and to filter and sort the items.\n * The edit-template is optional and used to edit the items. For the edit capability, the table must be part of a reactive form.\n * The items are displayed as table rows.\n * The table supports lazy loading, row selection, row menus, and context menus.\n * \n * @example\n * <rw-table\n *   [apiName]=\"apiName\"\n *   [searchTemplate]=\"searchTemplate\"\n *   [editTemplate]=\"editTemplate\"\n *   [rows]=\"rows\"\n *   [rowsPerPageOptions]=\"[10, 25, 50]\"\n *   [headerMenu]=\"headerMenu\"\n *   [rowMenu]=\"rowMenu\"\n *   [rowStyleClass]=\"rowStyleClass\"\n *   [cellStyleClass]=\"cellStyleClass\"\n *   [totalRecords]=\"totalRecords\"\n *   [multiSortMeta]=\"multiSortMeta\"\n *   [styleClass]=\"styleClass\"\n *   [tableStyle]=\"tableStyle\"\n *   [scrollable]=\"scrollable\"\n *   [scrollHeight]=\"scrollHeight\"\n *   [selectionMode]=\"selectionMode\"\n *   [rowHover]=\"rowHover\"\n *   [selection]=\"selection\"\n *   [contextMenuItems]=\"contextMenuItems\"\n *   [isLoading]=\"isLoading\"\n *   (onFilterOrSortChanged)=\"onFilterOrSortChanged($event)\"\n *   (onRowSelect)=\"onRowSelect($event)\"\n *   (onRowUnselect)=\"onRowUnselect($event)\"\n *   (selectionChange)=\"selectionChange($event)\">\n * </rw-table>\n * \n */\n@Component({\n  selector: 'rw-table',\n  templateUrl: './restworld-table.component.html',\n  styleUrls: ['./restworld-table.component.css'],\n  viewProviders: [{\n    provide: ControlContainer,\n    deps: [[Optional, FormArrayName]],\n    useFactory: (arrayName: FormArrayName) => arrayName, }]\n  })\nexport class RestWorldTableComponent<TListItem extends Record<string, any>> {\n  /**\n   * The name of the api.\n   * For the editing capability, you must also set the editTemplate and the formArray.\n   */\n  @Input()\n  public apiName?: string;\n\n  private _formArray?: FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>>;\n\n  /**\n   * The form array that contains the form groups for the items.\n   * Bind this to the form array that contains the form groups for the items.\n   * Each entry in the array represents one row in the currently displayed page of the table.\n   * For the editing capability, you must also set the apiName and the editTemplate.\n   */\n  @Input()\n  public set formArray(value: FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>> | undefined) {\n    this._formArray = value;\n  }\n\n  public get formArray(): FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>> | undefined {\n    return this._formArray ?? this._controlContainer?.control as FormArray<FormGroup<{[K in keyof TListItem] : AbstractControl<unknown>}>> | undefined;\n  }\n\n  private _searchTemplate: Template = new Template({properties: []});\n\n  /**\n   * The template that is used to display the table columns and to filter and sort the items.\n   * Bind this to the template that is used to display the table columns and to filter and sort the items.\n   * Normally this is returned from the backend as part of the hal-forms resource from a list endpoint.\n   */\n  @Input({ required: true })\n  public set searchTemplate(value: Template){\n    this._searchTemplate = value;\n    this._columns = value?.properties.filter(p => p.type !== PropertyType.Hidden) ?? [];\n    this.setSortFieldAndSortOrder(value)\n  }\n\n  public get searchTemplate() {\n    return this._searchTemplate;\n  }\n\n  private _editTemplate?: Template;\n\n  /**\n   * The template that is used to edit the items.\n   * Bind this to the template that is used to edit the items.\n   * Normally this is returned from the backend as part of the hal-forms resource from a list endpoint.\n   * For the editing capability, you must also set the apiName and the formArray.\n   */\n  @Input()\n  public set editTemplate(value: Template | undefined){\n    this._editTemplate = value;\n    this.updateEditProperties();\n    this.updateFormArray();\n  }\n\n  public get editTemplate() {\n    return this._editTemplate;\n  }\n\n  private _editProperties: Record<string, Property<SimpleValue, string, string>> = {};\n  public get editProperties() {\n    return this._editProperties;\n  }\n\n  public get isEditable() {\n    return this.editTemplate !== undefined && this.formArray !== undefined && this.apiName;\n  }\n\n  private _rows: TListItem[] = [];\n  public get rows() {\n    return this._rows;\n  }\n\n  /**\n   * The items that are displayed as table rows.\n   * Bind this to the items that are displayed as table rows.\n   * Normally this is returned from the backend as part of the hal-forms resource from a list endpoint.\n   */\n  @Input({ required: true })\n  public set rows(value: TListItem[]) {\n    this._rows = value;\n    this.updateCalculatedFunctionValues(value);\n    this.updateFormArray();\n  }\n\n  /**\n   * The possible values for the number of rows per page.\n   * The default is [10, 25, 50].\n   */\n  @Input()\n  public rowsPerPageOptions = [10, 25, 50];\n\n  /**\n   * An optional menu that is displayed at the top right of the table.\n   * @see RestWorldMenuButtonComponent\n   */\n  @Input()\n  public headerMenu: MenuItem[] = [];\n\n  private _rowMenu: (row: TListItem, openedByRightClick: boolean) => MenuItem[] = () => [];\n  public get rowMenu(): (row: TListItem, openedByRightClick: boolean) => MenuItem[] {\n    return this._rowMenu;\n  }\n\n  /**\n   * A function that returns the menu for a row.\n   * Based on the openedByRightClick parameter, the function can return different menus.\n   * The menu when it has not been opened by a right click is displayed in an extra column to the right of the table if `showRowMenuAsColumn` is `true`.\n   * The menu when it has been opened by a right click is displayed as a context menu if `showRowMenuOnRightClick` is `true`.\n   * @param row The row for which to return the menu.\n   * @param openedByRightClick Indicates whether the menu was opened by a right click.\n   * @returns The menu for the row.\n   * @see showRowMenuAsColumn\n   * @see showRowMenuOnRightClick\n   */\n  @Input()\n  public set rowMenu(value: (row: TListItem, openedByRightClick: boolean) => MenuItem[]) {\n    this._rowMenu = value;\n    this.updateRowMenus(this.rows);\n  }\n\n  private _rowMenus: MenuItem[][] = [];\n\n  private updateCalculatedFunctionValues(value: TListItem[]) {\n    this.updateRowMenus(value);\n    this.updateRowStyles(value);\n    this.updateCellStyles(value);\n  }\n\n  private updateCellStyles(value: TListItem[]) {\n    this._cellStyleClasses = value.map((r, ri) => Object.fromEntries(this.columns.map((c, ci) => [c.name, this.cellStyleClass(r, c, ri, ci)])));\n  }\n\n  private updateRowStyles(value: TListItem[]) {\n    this._rowStyleClasses = value.map((r, i) => this.rowStyleClass(r, i));\n  }\n\n  private updateRowMenus(value: TListItem[]) {\n    if (this.showRowMenuAsColumn)\n      this._rowMenus = value.map(r => this.rowMenu(r, false));\n  }\n\n  public get rowMenus() {\n    return this._rowMenus;\n  }\n\n  public get showMenuColumn() {\n    return this.headerMenu.length > 0 || (this.showRowMenuAsColumn && this.rowMenus.some(m => m.length > 0));\n  }\n\n  /**\n   * Indicates whether the row menu is displayed as a column to the right of the table.\n   */\n  @Input()\n  public showRowMenuAsColumn = true;\n\n  /**\n   * Indicates whether the row menu is displayed as a context menu when the user right clicks on a row.\n   */\n  @Input()\n  public showRowMenuOnRightClick = true;\n\n  private _rowStyleClass: (row: TListItem, rowIndex: number) => string = () => \"\";\n  public get rowStyleClass(): (row: TListItem, rowIndex: number) => string {\n    return this._rowStyleClass;\n  }\n\n  /**\n   * A function that returns the style class for a row.\n   * @param row The row for which to return the style class.\n   * @param rowIndex The index of the row on the currently displayed page.\n   * @returns The style class for the row.\n   */\n  @Input()\n  public set rowStyleClass(value: (row: TListItem, rowIndex: number) => string) {\n    this._rowStyleClass = value;\n    this.updateRowStyles(this.rows);\n  }\n\n  private _rowStyleClasses: string[] = [];\n  public get rowStyleClasses() {\n    return this._rowStyleClasses;\n  }\n\n  private _cellStyleClass: (row: TListItem, column: Property<SimpleValue, string, string>, rowIndex: number, columnIndex: number) => string = () => \"\";\n  public get cellStyleClass(): (row: TListItem, column: Property<SimpleValue, string, string>, rowIndex: number, columnIndex: number) => string {\n    return this._cellStyleClass;\n  }\n  /**\n   * A function that returns the style class for a cell.\n   * @param row The row for which to return the style class.\n   * @param column The column for which to return the style class.\n   * @param rowIndex The index of the row on the currently displayed page.\n   * @param columnIndex The index of the column.\n   * @returns The style class for the cell.\n   */\n  @Input()\n  public set cellStyleClass(value: (row: TListItem, column: Property<SimpleValue, string, string>, rowIndex: number, columnIndex: number) => string) {\n    this._cellStyleClass = value;\n    this.updateCellStyles(this.rows);\n  }\n\n  private _cellStyleClasses: Record<string,string>[] = [];\n  public get cellStyleClasses() {\n    return this._cellStyleClasses;\n  }\n\n  @Input()\n  public totalRecords = 0;\n\n  public constructor(\n    private readonly _controlContainer: ControlContainer,\n    private readonly _formService: FormService,) {\n  }\n\n  private setSortFieldAndSortOrder(template: Template | undefined) {\n    const orderBy = template?.properties?.find(p => p?.name === \"$orderby\")?.value;\n\n    if(orderBy === null || orderBy === undefined || typeof orderBy !== 'string')\n    return;\n\n    const [field, order] = orderBy.split(\" \");\n    const orderAsNumber = order?.toLowerCase() === \"desc\" ? -1 : 1;\n\n    if (this.multiSortMeta?.length !== 1 || this.multiSortMeta[0].field !== field || this.multiSortMeta[0].order !== orderAsNumber)\n      this.multiSortMeta = [{field: field, order: orderAsNumber}]\n  }\n\n  public multiSortMeta?: SortMeta[] | null;\n\n  /**\n   * The style class for the table.\n   * The default is \"\".\n   */\n  @Input()\n  public styleClass: string = \"\";\n\n  /**\n   * The inline style for the table.\n   */\n  @Input()\n  public tableStyle?: Record<string,string>;\n\n  /**\n   * Indicates whether the table is scrollable.\n   * The default is `true`.\n   */\n  @Input()\n  public scrollable: boolean = true;\n\n  /**\n   * The height of the scrollable table.\n   * The default is \"flex\".\n   */\n  @Input()\n  public scrollHeight: string = \"flex\";\n\n  /**\n   * Emitted when the filter or sort parameters have changed.\n   * Subscribe to this event to load the items from the backend.\n   * This is one of the core features of the table.\n   */\n  @Output()\n  public onFilterOrSortChanged = new EventEmitter<ODataParameters>();\n\n  /**\n   * Emitted when a row has been selected.\n   */\n  @Output()\n  public onRowSelect = new EventEmitter<TListItem>();\n\n  /**\n   * Emitted when a row has been unselected.\n   */\n  @Output()\n  public onRowUnselect = new EventEmitter<TListItem>();\n\n  /**\n   * The mode how rows can be selected.\n   * The default is `null` which means rows cannot be selected.\n   */\n  @Input()\n  public selectionMode: \"single\" | \"multiple\" | null = null;\n\n  /**\n   * Indicates whether the table rows are highlighted when the mouse hovers over them.\n   */\n  @Input()\n  public rowHover: boolean = false;\n\n  /**\n   * The currently selected rows.\n   */\n  @Input()\n  public get selection(): TListItem[] {\n    return _.isArray(this._selection) ? this._selection : [this._selection];\n  }\n  public set selection(value: TListItem[]) {\n    this._selection = value;\n  }\n  public _selection: TListItem | TListItem[] = [];\n\n  /**\n   * Emitted when the selection has changed.\n   * @param event The new selection.\n   */\n  @Output()\n  selectionChange: EventEmitter<TListItem[]> = new EventEmitter();\n\n  @ViewChild(\"contextMenu\")\n  contextMenu?: ContextMenu;\n\n  private _contextMenuItems: MenuItem[] = [];\n  public get contextMenuItems() {\n    return this._contextMenuItems;\n  }\n\n  /**\n   * Indicates whether the table is currently loading.\n   * Set this to true while loading new items from the backend when reacting to the `onFilterOrSortChanged` event.\n   */\n  @Input()\n  public isLoading = false;\n\n  private _columns: Property<SimpleValue, string, string>[] = [];\n  public get columns(): Property<SimpleValue, string, string>[] {\n    return this._columns;\n  }\n\n  private _rowsBeforeCurrentPage: number = 0;\n  public get rowsBeforeCurrentPage(): number {\n    return this._rowsBeforeCurrentPage;\n  }\n\n  private static readonly _dateFormat = new Date(3333, 10, 22) // months start at 0 in JS\n    .toLocaleDateString()\n    .replace(\"22\", \"dd\")\n    .replace(\"11\", \"MM\")\n    .replace(\"3333\", \"yy\")\n    .replace(\"33\", \"y\");\n\n  public get dateFormat(): string {\n    return RestWorldTableComponent._dateFormat;\n  }\n\n  private static readonly _timeFormat = new Date(1, 1, 1, 22, 33, 44)\n    .toLocaleTimeString()\n    .replace(\"22\", \"hh\")\n    .replace(\"33\", \"mm\")\n    .replace(\"44\", \"ss\");\n\n  public get timeFormat() {\n    return RestWorldTableComponent._timeFormat;\n  }\n\n  public get PropertyType(): typeof PropertyType {\n    return PropertyType;\n  }\n\n  public load(event: TableLazyLoadEvent) {\n    this.multiSortMeta = event.multiSortMeta;\n    this._rowsBeforeCurrentPage = event.first ?? 0;\n    const parameters = ODataService.createParametersFromTableLoadEvent(event, this.searchTemplate);\n    this.onFilterOrSortChanged.emit(parameters);\n  }\n\n  public openContextMenu(event: MouseEvent, row: TListItem): void {\n    if (!this.showRowMenuOnRightClick || this.contextMenu === undefined)\n      return;\n\n    this._contextMenuItems = this.rowMenu(row, true);\n    this.contextMenu.show(event);\n    event.stopPropagation();\n  }\n\n  public onRowSelectInternal(event: TableRowSelectEvent): void {\n    this.onRowSelect.emit(event.data);\n  }\n\n  public onRowUnselectInternal(event: TableRowUnSelectEvent): void {\n    this.onRowUnselect.emit(event.data);\n  }\n\n  public onSelectionChangeInternal(event: TListItem | TListItem[]): void {\n    this.selectionChange.emit(_.isArray(event) ? event : [event]);\n  }\n\n  public toColumnFilterType(propertyType: PropertyType) : ColumnFilterType{\n    switch(propertyType) {\n      case PropertyType.Number:\n      case PropertyType.Percent:\n      case PropertyType.Currency:\n      case PropertyType.Month:\n        return ColumnFilterType.numeric;\n      case PropertyType.Bool:\n        return ColumnFilterType.boolean;\n      case PropertyType.Date:\n      case PropertyType.DatetimeLocal:\n      case PropertyType.DatetimeOffset:\n        return ColumnFilterType.date;\n      default:\n        return ColumnFilterType.text;\n    }\n  }\n\n  public toMatchMode(propertyType: PropertyType): string | undefined {\n    // There is a bug in PrimeNG returning CONTAINS for boolean columns\n    // Once the bug has been fixed, we can remove this workaround\n    // https://github.com/primefaces/primeng/issues/14210\n    if (propertyType === PropertyType.Bool)\n      return FilterMatchMode.EQUALS;\n\n      return undefined;\n  }\n\n  public showInputField(column: Property): boolean {\n    if (!this.isEditable)\n      return false;\n\n    const editProperty = this.editProperties[column.name];\n\n    return editProperty !== undefined && editProperty.type !== PropertyType.Hidden && !editProperty.readOnly;\n  }\n\n  private updateFormArray(): void {\n    if(!this.isEditable || !this.rows || !this.formArray || !this.editTemplate)\n      return;\n\n    this.formArray.clear();\n\n    const newControls = this.rows\n      .map(r => {\n        const formGroup = this._formService.createFormGroupFromTemplate(this.editTemplate!) as FormGroup;\n        formGroup.patchValue(r);\n        return formGroup;\n      });\n\n    for (const control of newControls)\n      this.formArray.push(control);\n  }\n\n  private updateEditProperties(): void {\n    if (!this.editTemplate)\n      return;\n\n    this._editProperties = Object.fromEntries(this.editTemplate.properties.map(p => [ p.name, p ]));\n  }\n}\n","<p-table\n  #table\n  [value]=\"rows\"\n  [columns]=\"columns\"\n  [lazy]=\"true\"\n  [lazyLoadOnInit]=\"false\"\n  (onLazyLoad)=\"load($event)\"\n  responsiveLayout=\"scroll\"\n  [paginator]=\"true\"\n  [rowsPerPageOptions]=\"rowsPerPageOptions\"\n  [rows]=\"rows.length\"\n  [totalRecords]=\"totalRecords\"\n  [loading]=\"isLoading\"\n  sortMode=\"multiple\"\n  [multiSortMeta]=\"multiSortMeta\"\n  [styleClass]=\"styleClass\"\n  [tableStyle]=\"tableStyle\"\n  [scrollable]=\"scrollable\"\n  [scrollHeight]=\"scrollHeight\"\n  [selectionMode]=\"selectionMode\"\n  (onRowSelect)=\"onRowSelectInternal($event)\"\n  (onRowUnselect)=\"onRowUnselectInternal($event)\"\n  [rowHover]=\"rowHover\"\n  [(selection)]=\"_selection\"\n  (selectionChange)=\"onSelectionChangeInternal($event)\">\n\n  <ng-template pTemplate=\"header\" let-columns>\n    <tr>\n        <th *ngFor=\"let col of columns\" [pSortableColumn]=\"col.name\">\n            <div class=\"p-d-flex p-jc-between p-ai-center\">\n                {{col.prompt}}\n                <ng-container *ngIf=\"!col.readOnly\">\n                  <p-sortIcon [field]=\"col.name\"></p-sortIcon>\n                  <p-columnFilter [type]=\"toColumnFilterType(col.type)\" [matchMode]=\"toMatchMode(col.type)\" [field]=\"col.name\" display=\"menu\"></p-columnFilter>\n                </ng-container>\n            </div>\n        </th>\n        <th *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button [items]=\"headerMenu\"></rw-menu-button>\n        </th>\n    </tr>\n  </ng-template>\n\n  <ng-template pTemplate=\"body\" let-entity let-columns=\"columns\" let-rowIndex=\"rowIndex\">\n    <tr (contextmenu)=\"openContextMenu($event, entity)\" [pSelectableRow]=\"entity\" [pSelectableRowDisabled]=\"selectionMode === null\" [className]=\"rowStyleClasses[rowIndex - (table.first ?? 0)]\">\n      <td [ngSwitch]=\"col.type\" *ngFor=\"let col of columns\" [className]=\"cellStyleClasses[rowIndex - (table.first ?? 0)][col.name]\">\n          <ng-container *ngIf=\"showInputField(col); else textField\" [formGroup]=\"formArray!.controls[rowIndex - (table.first ?? 0)]\" >\n            <rw-input [apiName]=\"apiName!\" [property]=\"editProperties[col.name]\"></rw-input>\n          </ng-container>\n          <ng-template #textField>\n            <ng-container *ngSwitchCase=\"PropertyType.Text\">\n                <rw-avatar *ngIf=\"col.name === 'createdBy' || col.name === 'lastChangedBy'\" [user]=\"entity[col.name]\"></rw-avatar>\n                <span *ngIf=\"col.name !== 'createdBy' && col.name !== 'lastChangedBy'\">{{entity[col.name]}}</span>\n            </ng-container>\n            <span *ngSwitchCase=\"PropertyType.Number\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Percent\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Currency\" class=\"flex justify-content-end\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Bool\" class=\"flex justify-content-center\"><p-triStateCheckbox [(ngModel)]=\"entity[col.name]\" [readonly]=\"true\"></p-triStateCheckbox></span>\n            <span *ngSwitchCase=\"PropertyType.Date\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Time\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.Duration\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeLocal\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.DatetimeOffset\" [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:PropertyType.Date}}</span>\n            <span *ngSwitchCase=\"PropertyType.Collection\" class=\"flex justify-content-end\"><p *ngFor=\"let arrayElement of entity[col.name]\">{{arrayElement | json}}</p></span>\n            <span *ngSwitchCase=\"PropertyType.Object\" class=\"flex justify-content-end\">{{entity[col.name] | json}}</span>\n            <span *ngSwitchDefault [pTooltip]=\"entity[col.name]\">{{entity[col.name] | propertyTypeFormat:col.type}}</span>\n          </ng-template>\n        </td>\n        <td *ngIf=\"showMenuColumn\" class=\"flex justify-content-end\">\n          <rw-menu-button *ngIf=\"showRowMenuAsColumn\" [items]=\"rowMenus[rowIndex - (table.first ?? 0)]\"></rw-menu-button>\n        </td>\n    </tr>\n  </ng-template>\n\n  <p-contextMenu #contextMenu appendTo=\"body\" [model]=\"contextMenuItems\"></p-contextMenu>\n</p-table>\n"]}

package/esm2022/lib/models/events.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJlc3R3b3JsZC1jbGllbnQvc3JjL2xpYi9tb2RlbHMvZXZlbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogUmVwcmVzZW50cyB0aGUgZXZlbnQgdGhhdCBpcyBlbWl0dGVkIHdoZW4gdGhlIHZhbHVlIG9mIGEgZHJvcGRvd24gY29tcG9uZW50IGNoYW5nZXMuXHJcbiAqIEB0ZW1wbGF0ZSBUIFRoZSB0eXBlIG9mIHRoZSB2YWx1ZSB0aGF0IGlzIHNlbGVjdGVkIGluIHRoZSBkcm9wZG93bi5cclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgRHJvcGRvd25DaGFuZ2VFdmVudDxUPiB7XHJcbiAgb3JpZ2luYWxFdmVudDogRXZlbnQ7XHJcbiAgdmFsdWU6IFQ7XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LXJlc3R3b3JsZC1jbGllbnQvc3JjL2xpYi9tb2RlbHMvZXZlbnRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBUZW1wbGF0ZSB9IGZyb20gXCJAd2VydHp1aS9uZ3gtaGFsLWNsaWVudFwiO1xyXG5cclxuLyoqXHJcbiAqIFJlcHJlc2VudHMgdGhlIGV2ZW50IHRoYXQgaXMgZW1pdHRlZCB3aGVuIHRoZSB2YWx1ZSBvZiBhIGRyb3Bkb3duIGNvbXBvbmVudCBjaGFuZ2VzLlxyXG4gKiBAdGVtcGxhdGUgVCBUaGUgdHlwZSBvZiB0aGUgdmFsdWUgdGhhdCBpcyBzZWxlY3RlZCBpbiB0aGUgZHJvcGRvd24uXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIERyb3Bkb3duQ2hhbmdlRXZlbnQ8VD4ge1xyXG4gIG9yaWdpbmFsRXZlbnQ6IEV2ZW50O1xyXG4gIHZhbHVlOiBUO1xyXG59XHJcblxyXG4vKipcclxuICogRXZlbnQgZW1pdHRlZCBhZnRlciBhIHN1Y2Nlc3NmdWwgc3VibWl0IHdoaWNoIGNoYW5nZWQgdGhlIHRlbXBsYXRlLlxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBBZnRlclN1Ym1pdE9rRXZlbnQge1xyXG4gIC8qKlxyXG4gICAqIFRoZSB0ZW1wbGF0ZSBiZWZvcmUgdGhlIHN1Ym1pdC5cclxuICAgKi9cclxuICBvbGQ6IFRlbXBsYXRlO1xyXG4gIC8qKlxyXG4gICAqIFRoZSB0ZW1wbGF0ZSBhZnRlciB0aGUgc3VibWl0LlxyXG4gICAqL1xyXG4gIG5ldzogVGVtcGxhdGU7XHJcbiAgLyoqXHJcbiAgICogVGhlIEhUVFAgc3RhdHVzIGNvZGUgb2YgdGhlIHJlc3BvbnNlLlxyXG4gICAqL1xyXG4gIHN0YXR1czogMjAwO1xyXG59XHJcblxyXG4vKipcclxuICogRXZlbnQgZW1pdHRlZCBhZnRlciBhIHN1Y2Nlc3NmdWwgc3VibWl0IHdoaWNoIGNyZWF0ZWQgYSBuZXcgcmVzb3VyY2UuXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFmdGVyU3VibWl0UmVkaXJlY3RFdmVudCB7XHJcbiAgLyoqXHJcbiAgICogVGhlIExvY2F0aW9uIGhlYWRlciBvZiB0aGUgcmVzcG9uc2UgaWYgdGhlIHN0YXR1cyBpcyAyMDEuXHJcbiAgICovXHJcbiAgbG9jYXRpb24/OiBzdHJpbmc7XHJcbiAgLyoqXHJcbiAgICogVGhlIEhUVFAgc3RhdHVzIGNvZGUgb2YgdGhlIHJlc3BvbnNlLlxyXG4gICAqL1xyXG4gIHN0YXR1czogMjAxO1xyXG59XHJcbiJdfQ==