@ohioepa/oepa-ui-lib 1.1.0

package/esm2022/lib/shopping-cart/shopping-cart-view/shopping-cart-view.component.mjs

@@ -0,0 +1,190 @@
+import { Component } from '@angular/core';
+import { ConfirmationModalComponent } from '../../confirmation-modal/confirmation-modal.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "ngx-bootstrap/modal";
+import * as i3 from "../shopping-cart.service";
+import * as i4 from "@angular/common";
+import * as i5 from "../../table/table.component";
+export class ShoppingCartViewComponent {
+    router;
+    route;
+    modalService;
+    shoppingCartService;
+    serviceName;
+    title;
+    returnLabel;
+    returnUrl;
+    shoppingCart;
+    empty = true;
+    loading = true;
+    errorMessage = '';
+    imageRoot = '/AngularWebApp/assets/images';
+    checkOutInProgress = false;
+    totalColumn = 'itemDescription';
+    itemNumberLabel;
+    itemClassificationLabel;
+    itemNameLabel;
+    itemDescriptionLabel = '';
+    tblHeader = {
+        columns: [
+            { title: 'Remove Item', id: 'deleteItem', sort: 'none', hyperlink: true, className: 'oepa-table-header-center' },
+            { title: 'Fee', id: 'fee', sort: 'none' },
+        ]
+    };
+    tblConfig = {
+        classNames: ['table-bordered'],
+        hideFooter: true
+    };
+    tblData = [];
+    constructor(router, route, modalService, shoppingCartService) {
+        this.router = router;
+        this.route = route;
+        this.modalService = modalService;
+        this.shoppingCartService = shoppingCartService;
+        const params = route.snapshot.data[0];
+        this.serviceName = params.serviceName;
+        this.title = params.title;
+        this.returnLabel = params.returnLabel;
+        this.returnUrl = params.returnUrl;
+        this.itemNumberLabel = params.itemNumberLabel;
+        this.itemClassificationLabel = params.itemClassificationLabel;
+        this.itemNameLabel = params.itemNameLabel;
+    }
+    ngOnInit() {
+        this.updateHeaders();
+        this.refresh();
+    }
+    /**
+     * Set headers based on the labels defined for this shopping cart
+     */
+    updateHeaders() {
+        // process labels in reverse order since unshift places item at the beginning of the array
+        if (this.itemDescriptionLabel) {
+            this.tblHeader.columns.unshift({ title: this.itemDescriptionLabel, id: 'itemDescription', sort: 'none' });
+            this.totalColumn = 'itemDescription';
+        }
+        if (this.itemNameLabel) {
+            this.tblHeader.columns.unshift({ title: this.itemNameLabel, id: 'itemName', sort: 'none' });
+            this.totalColumn = 'itemName';
+        }
+        if (this.itemClassificationLabel) {
+            this.tblHeader.columns.unshift({ title: this.itemClassificationLabel, id: 'itemClassification', sort: 'none' });
+            this.totalColumn = 'itemClassification';
+        }
+        if (this.itemNumberLabel) {
+            this.tblHeader.columns.unshift({ title: this.itemNumberLabel, id: 'itemNumber', sort: 'none' });
+            this.totalColumn = 'itemNumber';
+        }
+    }
+    refresh() {
+        this.loading = true;
+        this.errorMessage = '';
+        this.shoppingCartService.retrieveShoppingCart(this.serviceName).subscribe({
+            next: shoppingCart => {
+                this.shoppingCart = shoppingCart;
+                this.loadTable();
+                this.loading = false;
+            }, error: err => {
+                this.errorMessage = 'Failed retrieving shopping cart data: ' + err;
+                this.loading = false;
+            }
+        });
+    }
+    loadTable() {
+        this.tblData = [];
+        this.empty = true;
+        if (this.shoppingCart && this.shoppingCart.cartItems) {
+            this.shoppingCart.cartItems.forEach(cartItem => {
+                this.empty = false;
+                let row = this.convertCartItemToTableRow(cartItem);
+                this.tblData.push(row);
+            });
+            this.tblData.push({ cells: [
+                    { id: 'itemNumber', value: (this.totalColumn === 'itemNumber' ? 'Total Amount Due:' : ''), className: 'oepa-table-gray oepa-table-bold' },
+                    { id: 'itemClassification', value: (this.totalColumn === 'itemClassification' ? 'Total Amount Due:' : ''), className: 'oepa-table-gray oepa-table-bold' },
+                    { id: 'itemName', value: (this.totalColumn === 'itemName' ? 'Total Amount Due:' : ''), className: 'oepa-table-gray oepa-table-bold' },
+                    { id: 'itemDescription', value: (this.totalColumn === 'itemDescription' ? 'Total Amount Due:' : ''), className: 'oepa-table-gray oepa-table-bold' },
+                    { id: 'deleteItem', value: '', className: 'oepa-table-gray' },
+                    { id: 'fee', value: this.shoppingCart?.totalAmount?.formattedString, sortValue: this.shoppingCart?.totalAmount?.cents, iconClassName: 'oepa-undeline-cell', className: 'oepa-table-gray oepa-table-bold' }
+                ] });
+            this.tblData = this.tblData.slice();
+        }
+    }
+    convertCartItemToTableRow(cartItem) {
+        let row = {
+            cells: [
+                { id: 'itemNumber', value: cartItem.itemNumber },
+                { id: 'itemClassification', value: cartItem.itemClassification },
+                { id: 'itemName', value: cartItem.itemName },
+                { id: 'itemDescription', value: cartItem.description },
+                { id: 'deleteItem', value: '', iconClassName: 'fa fa-minus-circle', className: 'text-center' },
+                { id: 'fee', value: cartItem.unitPrice?.formattedString, sortValue: cartItem.unitPrice?.cents },
+            ],
+            dataSource: cartItem
+        };
+        return row;
+    }
+    onCellClick(event) {
+        if (event.columnId === 'deleteItem') {
+            this.deleteFromCart(event.row.dataSource.typeID, event.row.dataSource.description, this.shoppingCart);
+        }
+    }
+    deleteFromCart(id, description, cart) {
+        const modal = this.modalService.show(ConfirmationModalComponent, { ignoreBackdropClick: true });
+        modal.content.headerText = 'Remove item from cart?';
+        modal.content.bodyText = 'Are you sure you want to remove ' + description + ' from the shopping cart?';
+        modal.content.confirmBtnLabel = 'Yes';
+        modal.content.cancelBtnLabel = 'No';
+        modal.content.confirmClicked.subscribe(() => {
+            this.deleteItemFromCart(id, cart);
+        });
+    }
+    deleteItemFromCart(id, cart) {
+        if (cart) {
+            this.shoppingCartService.removeShoppingCartItem(id, cart).subscribe({
+                next: updatedCart => {
+                    this.shoppingCart = updatedCart;
+                    this.loadTable();
+                }, error: err => {
+                    this.errorMessage = 'Failed removing item from cart: ' + err;
+                }
+            });
+        }
+    }
+    goBack() {
+        this.router.navigate([this.returnUrl], { relativeTo: this.route.parent });
+    }
+    onCheckout() {
+        const modal = this.modalService.show(ConfirmationModalComponent, { ignoreBackdropClick: true });
+        modal.content.headerText = 'Checkout';
+        modal.content.bodyText = 'Do you want to submit all of the applications in the shopping cart?';
+        modal.content.confirmBtnLabel = 'Yes';
+        modal.content.cancelBtnLabel = 'No';
+        modal.content.confirmClicked.subscribe(() => {
+            this.checkout();
+        });
+    }
+    checkout() {
+        if (this.shoppingCart) {
+            this.errorMessage = '';
+            this.checkOutInProgress = true;
+            this.shoppingCartService.checkOut(this.shoppingCart).subscribe({
+                next: transactionID => {
+                    // navigate to CBOSS payment screen
+                    window.location.href = '/portal/paymentSubmissionAction.po?transactionID=' + transactionID;
+                }, error: err => {
+                    this.checkOutInProgress = false;
+                    this.errorMessage = 'Checkout failed: ' + err;
+                }
+            });
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShoppingCartViewComponent, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.BsModalService }, { token: i3.ShoppingCartService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: ShoppingCartViewComponent, selector: "oepa-shopping-cart-view", ngImport: i0, template: "<div class=\"container-fluid\">\n  <div class=\"row\">\n      <div class=\" col-sm-12\">\n          <h2><b>{{title}}</b></h2>\n        </div>\n    <div *ngIf=\"loading || empty\" class=\"col-sm-12 text-center\">\n      <div class=\" alert alert-info \">\n        <h3><em>{{ loading ? 'Loading...' : 'Cart is empty' }}</em></h3>\n        <img *ngIf=\"loading\" class=\"oepa-icon\" src=\"{{imageRoot}}/blue-load.gif\" />\n      </div>\n    </div>\n    <div *ngIf=\"!loading && !empty\" class=\"col-sm-12\">\n      <oepa-table [config]=\"tblConfig\" [data]=\"tblData\" [header]=\"tblHeader\" tableId=\"ShoppingCartTable\" (cellClicked)=\"onCellClick($event)\"></oepa-table>\n    </div>\n    <div *ngIf=\"errorMessage\" class=\"col-sm-12\">\n      <div class=\"alert alert-danger\">{{errorMessage}}</div>\n    </div>\n    <div *ngIf=\"!checkOutInProgress\" class=\"col-12 text-center\">\n        <button class=\"btn btn-primary mr-2\" id=\"returnToPageButton\" (click)=\"goBack()\">\n          {{returnLabel}}</button>\n        <button *ngIf=\"!empty\" class=\"btn btn-primary mr-2\" id=\"checkoutBtn\" (click)=\"onCheckout()\">\n          Checkout</button>\n      </div>\n      <div *ngIf=\"checkOutInProgress\" class=\"col-12 text-center\">\n        <div class=\"alert alert-info\">\n          <span class=\"spinner-border text-primary\" role=\"status\"></span>\n          Checking out...\n        </div>\n      </div>\n  </div>\n</div>", styles: [""], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.TableComponent, selector: "oepa-table", inputs: ["tableId", "config", "complexHeader", "header", "customBtnLabel", "customBtnVisible", "customBtnEnabled", "data", "totalRow"], outputs: ["cellClicked", "actionClicked", "rowSelected", "customBtnClicked"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShoppingCartViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'oepa-shopping-cart-view', template: "<div class=\"container-fluid\">\n  <div class=\"row\">\n      <div class=\" col-sm-12\">\n          <h2><b>{{title}}</b></h2>\n        </div>\n    <div *ngIf=\"loading || empty\" class=\"col-sm-12 text-center\">\n      <div class=\" alert alert-info \">\n        <h3><em>{{ loading ? 'Loading...' : 'Cart is empty' }}</em></h3>\n        <img *ngIf=\"loading\" class=\"oepa-icon\" src=\"{{imageRoot}}/blue-load.gif\" />\n      </div>\n    </div>\n    <div *ngIf=\"!loading && !empty\" class=\"col-sm-12\">\n      <oepa-table [config]=\"tblConfig\" [data]=\"tblData\" [header]=\"tblHeader\" tableId=\"ShoppingCartTable\" (cellClicked)=\"onCellClick($event)\"></oepa-table>\n    </div>\n    <div *ngIf=\"errorMessage\" class=\"col-sm-12\">\n      <div class=\"alert alert-danger\">{{errorMessage}}</div>\n    </div>\n    <div *ngIf=\"!checkOutInProgress\" class=\"col-12 text-center\">\n        <button class=\"btn btn-primary mr-2\" id=\"returnToPageButton\" (click)=\"goBack()\">\n          {{returnLabel}}</button>\n        <button *ngIf=\"!empty\" class=\"btn btn-primary mr-2\" id=\"checkoutBtn\" (click)=\"onCheckout()\">\n          Checkout</button>\n      </div>\n      <div *ngIf=\"checkOutInProgress\" class=\"col-12 text-center\">\n        <div class=\"alert alert-info\">\n          <span class=\"spinner-border text-primary\" role=\"status\"></span>\n          Checking out...\n        </div>\n      </div>\n  </div>\n</div>" }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.BsModalService }, { type: i3.ShoppingCartService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"shopping-cart-view.component.js","sourceRoot":"","sources":["../../../../../../projects/oepa-ui-lib/src/lib/shopping-cart/shopping-cart-view/shopping-cart-view.component.ts","../../../../../../projects/oepa-ui-lib/src/lib/shopping-cart/shopping-cart-view/shopping-cart-view.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\nimport { Router, ActivatedRoute } from '@angular/router';\nimport { ShoppingCartService } from '../shopping-cart.service';\nimport { ShoppingCartItem, ShoppingCart } from '@ohioepa/oepa-ebiz-lib';\nimport { BsModalRef, BsModalService } from 'ngx-bootstrap/modal';\nimport { ConfirmationModalComponent } from '../../confirmation-modal/confirmation-modal.component';\nimport { ShoppingCartViewParameters } from './shopping-cart-view-parameters';\nimport { OepaTableHeader } from '../../table/oepa-table-header';\nimport { OepaTableCellClickEvent } from '../../table/oepa-table-cell-click-event';\nimport { OepaTableConfig } from '../../table/oepa-table-config';\nimport { OepaTableRow } from '../../table/oepa-table-row';\n\n@Component({\n  selector: 'oepa-shopping-cart-view',\n  templateUrl: './shopping-cart-view.component.html',\n  styleUrls: ['./shopping-cart-view.component.css']\n})\nexport class ShoppingCartViewComponent implements OnInit {\n  serviceName: string;\n  title: string;\n  returnLabel: string;\n  returnUrl: string;\n  shoppingCart: ShoppingCart | undefined;\n  empty = true;\n  loading = true;\n  errorMessage: string = '';\n  imageRoot = '/AngularWebApp/assets/images';\n  checkOutInProgress = false;\n  totalColumn: string = 'itemDescription';\n  itemNumberLabel: string;\n  itemClassificationLabel: string;\n  itemNameLabel: string;\n  itemDescriptionLabel: string = '';\n\n  tblHeader: OepaTableHeader = {\n    columns: [\n      { title: 'Remove Item', id: 'deleteItem', sort: 'none', hyperlink: true, className: 'oepa-table-header-center' },\n      { title: 'Fee', id: 'fee', sort: 'none' },\n    ]\n  };\n\n  tblConfig: OepaTableConfig = {\n    classNames: ['table-bordered'],\n    hideFooter: true\n  };\n\n  tblData: Array<OepaTableRow> = [];\n\n  constructor(private router: Router,\n    private route: ActivatedRoute,\n    private modalService: BsModalService, \n    private shoppingCartService: ShoppingCartService) {\n      const params: ShoppingCartViewParameters = <ShoppingCartViewParameters>route.snapshot.data[0];\n      this.serviceName = params.serviceName;\n      this.title = params.title;\n      this.returnLabel = params.returnLabel;\n      this.returnUrl = params.returnUrl;\n      this.itemNumberLabel = params.itemNumberLabel;\n      this.itemClassificationLabel = params.itemClassificationLabel;\n      this.itemNameLabel = params.itemNameLabel;\n  }\n\n  ngOnInit() {\n    this.updateHeaders();\n    this.refresh();\n  }\n\n  /**\n   * Set headers based on the labels defined for this shopping cart\n   */\n  private updateHeaders() {\n    // process labels in reverse order since unshift places item at the beginning of the array\n    if (this.itemDescriptionLabel) {\n      this.tblHeader.columns.unshift({ title: this.itemDescriptionLabel, id: 'itemDescription', sort: 'none' });\n      this.totalColumn = 'itemDescription';\n    }\n    if (this.itemNameLabel) {\n      this.tblHeader.columns.unshift({ title: this.itemNameLabel, id: 'itemName', sort: 'none' });\n      this.totalColumn = 'itemName';\n    }\n    if (this.itemClassificationLabel) {\n      this.tblHeader.columns.unshift({ title: this.itemClassificationLabel, id: 'itemClassification', sort: 'none' });\n      this.totalColumn = 'itemClassification';\n    }\n    if (this.itemNumberLabel) {\n      this.tblHeader.columns.unshift({ title: this.itemNumberLabel, id: 'itemNumber', sort: 'none' });\n      this.totalColumn = 'itemNumber';\n    }\n  }\n\n  private refresh() {\n    this.loading = true;\n    this.errorMessage = '';\n    this.shoppingCartService.retrieveShoppingCart(this.serviceName).subscribe({\n      next: shoppingCart => {\n      this.shoppingCart = shoppingCart;\n      this.loadTable();\n      this.loading = false;\n    }, error: err => {\n      this.errorMessage = 'Failed retrieving shopping cart data: ' + err;\n      this.loading = false;\n    }});\n  }\n\n  private loadTable() {\n    this.tblData = [];\n    this.empty = true;\n    if (this.shoppingCart && this.shoppingCart.cartItems) {\n      this.shoppingCart.cartItems.forEach(cartItem => {\n        this.empty = false;\n        let row = this.convertCartItemToTableRow(cartItem);\n        this.tblData.push(row);\n      });\n      this.tblData.push({ cells : [ \n        {id: 'itemNumber', value: (this.totalColumn === 'itemNumber' ? 'Total Amount Due:' : ''), className:'oepa-table-gray oepa-table-bold' },\n        {id: 'itemClassification', value: (this.totalColumn === 'itemClassification' ? 'Total Amount Due:' : ''), className:'oepa-table-gray oepa-table-bold' },\n        {id: 'itemName', value: (this.totalColumn === 'itemName' ? 'Total Amount Due:' : ''), className:'oepa-table-gray oepa-table-bold' },\n        {id: 'itemDescription', value: (this.totalColumn === 'itemDescription' ? 'Total Amount Due:' : ''), className:'oepa-table-gray oepa-table-bold' },\n        {id:'deleteItem', value:'',className:'oepa-table-gray' },\n        {id: 'fee',  value: this.shoppingCart?.totalAmount?.formattedString, sortValue: this.shoppingCart?.totalAmount?.cents, iconClassName:'oepa-undeline-cell', className:'oepa-table-gray oepa-table-bold'}\n      ]});\n      this.tblData = this.tblData.slice();\n    }\n  }\n\n  private convertCartItemToTableRow(cartItem: ShoppingCartItem): OepaTableRow {\n    let row: OepaTableRow = {\n      cells: [\n        { id: 'itemNumber', value: cartItem.itemNumber },\n        { id: 'itemClassification', value: cartItem.itemClassification },\n        { id: 'itemName', value: cartItem.itemName },\n        { id: 'itemDescription', value: cartItem.description },\n        { id: 'deleteItem', value: '', iconClassName: 'fa fa-minus-circle', className: 'text-center' },\n        { id: 'fee', value: cartItem.unitPrice?.formattedString, sortValue: cartItem.unitPrice?.cents },\n      ],\n      dataSource: cartItem\n    }\n    return row;\n  }\n\n  onCellClick(event: OepaTableCellClickEvent) {\n    if (event.columnId === 'deleteItem') {\n      this.deleteFromCart(event.row.dataSource.typeID, event.row.dataSource.description, this.shoppingCart);\n    }\n  }\n\n  private deleteFromCart(id: string, description: string, cart: ShoppingCart | undefined) {\n    const modal: BsModalRef = this.modalService.show(ConfirmationModalComponent, { ignoreBackdropClick: true });\n    (<ConfirmationModalComponent>modal.content).headerText = 'Remove item from cart?';\n    (<ConfirmationModalComponent>modal.content).bodyText = 'Are you sure you want to remove ' + description +  ' from the shopping cart?';\n    (<ConfirmationModalComponent>modal.content).confirmBtnLabel = 'Yes';\n    (<ConfirmationModalComponent>modal.content).cancelBtnLabel = 'No';\n    (<ConfirmationModalComponent>modal.content).confirmClicked.subscribe(() => {\n      this.deleteItemFromCart(id, cart);\n    });\n  }\n\n  private deleteItemFromCart(id: string, cart: ShoppingCart | undefined) {\n    if (cart) {\n      this.shoppingCartService.removeShoppingCartItem(id, cart).subscribe({\n        next: updatedCart => {\n        this.shoppingCart = updatedCart;\n        this.loadTable();\n      }, error: err => {\n        this.errorMessage = 'Failed removing item from cart: ' + err;\n      }});\n    }\n  }\n\n  goBack() {\n    this.router.navigate([this.returnUrl], { relativeTo: this.route.parent });\n  }\n\n  public onCheckout() {\n    const modal: BsModalRef = this.modalService.show(ConfirmationModalComponent, { ignoreBackdropClick: true });\n    (<ConfirmationModalComponent>modal.content).headerText = 'Checkout';\n    (<ConfirmationModalComponent>modal.content).bodyText = 'Do you want to submit all of the applications in the shopping cart?';\n    (<ConfirmationModalComponent>modal.content).confirmBtnLabel = 'Yes';\n    (<ConfirmationModalComponent>modal.content).cancelBtnLabel = 'No';\n    (<ConfirmationModalComponent>modal.content).confirmClicked.subscribe(() => {\n      this.checkout();\n    });\n  }\n\n  checkout() {\n    if (this.shoppingCart) {\n      this.errorMessage = '';\n      this.checkOutInProgress = true;\n      this.shoppingCartService.checkOut(this.shoppingCart).subscribe({\n        next: transactionID => {\n        // navigate to CBOSS payment screen\n        window.location.href = '/portal/paymentSubmissionAction.po?transactionID=' + transactionID;\n      }, error: err => {\n        this.checkOutInProgress = false;\n        this.errorMessage = 'Checkout failed: ' + err;\n      }});\n    }\n  }\n\n}\n","<div class=\"container-fluid\">\n  <div class=\"row\">\n      <div class=\" col-sm-12\">\n          <h2><b>{{title}}</b></h2>\n        </div>\n    <div *ngIf=\"loading || empty\" class=\"col-sm-12 text-center\">\n      <div class=\" alert alert-info \">\n        <h3><em>{{ loading ? 'Loading...' : 'Cart is empty' }}</em></h3>\n        <img *ngIf=\"loading\" class=\"oepa-icon\" src=\"{{imageRoot}}/blue-load.gif\" />\n      </div>\n    </div>\n    <div *ngIf=\"!loading && !empty\" class=\"col-sm-12\">\n      <oepa-table [config]=\"tblConfig\" [data]=\"tblData\" [header]=\"tblHeader\" tableId=\"ShoppingCartTable\" (cellClicked)=\"onCellClick($event)\"></oepa-table>\n    </div>\n    <div *ngIf=\"errorMessage\" class=\"col-sm-12\">\n      <div class=\"alert alert-danger\">{{errorMessage}}</div>\n    </div>\n    <div *ngIf=\"!checkOutInProgress\" class=\"col-12 text-center\">\n        <button class=\"btn btn-primary mr-2\" id=\"returnToPageButton\" (click)=\"goBack()\">\n          {{returnLabel}}</button>\n        <button *ngIf=\"!empty\" class=\"btn btn-primary mr-2\" id=\"checkoutBtn\" (click)=\"onCheckout()\">\n          Checkout</button>\n      </div>\n      <div *ngIf=\"checkOutInProgress\" class=\"col-12 text-center\">\n        <div class=\"alert alert-info\">\n          <span class=\"spinner-border text-primary\" role=\"status\"></span>\n          Checking out...\n        </div>\n      </div>\n  </div>\n</div>"]}

package/esm2022/lib/shopping-cart/shopping-cart.service.mjs

@@ -0,0 +1,89 @@
+import { Injectable } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+import { of } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ShoppingCartService {
+    http;
+    paymentUrl = '/ebiz/api/v1/payment/';
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * Retrieve a shopping cart for the current user for the provided serviceName.
+     * @param serviceName
+     * @returns Observable<ShoppingCart>
+     */
+    retrieveShoppingCart(serviceName) {
+        const headers = new HttpHeaders();
+        headers.append('Content-Type', 'application/json');
+        const url = this.paymentUrl + '/shoppingCart/' + serviceName;
+        return this.http.get(url, { headers: headers, responseType: 'json' });
+    }
+    /**
+     * Store cart in the database
+     * @param cart
+     * @returns Observable<ShoppingCart>
+     */
+    updateShoppingCart(cart) {
+        const headers = new HttpHeaders();
+        headers.append('Content-Type', 'application/json');
+        const url = this.paymentUrl + '/shoppingCart';
+        return this.http.post(url, cart, { headers: headers, responseType: 'json' });
+    }
+    /**
+     * Remove the item with the type id, id, from cart and store it in the database
+     * @param id
+     * @param cart
+     * @returns Observable<ShoppingCart>
+     */
+    removeShoppingCartItem(id, cart) {
+        if (id && cart && cart.cartItems) {
+            cart.cartItems = cart.cartItems.filter(item => {
+                return item.typeID !== id;
+            });
+            return this.updateShoppingCart(cart);
+        }
+        else {
+            return of(cart);
+        }
+    }
+    /**
+     * Add item to cart and store it in the database
+     * @param item
+     * @param cart
+     * @returns Observable<ShoppingCart>
+     */
+    addShoppingCartItem(item, cart) {
+        if (item && cart) {
+            if (!cart.cartItems) {
+                cart.cartItems = [];
+            }
+            cart.cartItems.push(item);
+            return this.updateShoppingCart(cart);
+        }
+        else {
+            return of(cart);
+        }
+    }
+    /**
+     * Perform checkout for cart. This will create revenues for all items in the cart and return
+     * a transaction id for the shopping cart as a whole.
+     * @param cart
+     * @returns Observable<string>
+     */
+    checkOut(cart) {
+        const headers = new HttpHeaders({ 'Content-Type': 'application/json; odata=verbose' });
+        const url = this.paymentUrl + '/shoppingCart/' + cart.serviceName + '/checkout';
+        return this.http.post(url, cart, { headers: headers, responseType: 'json' });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShoppingCartService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShoppingCartService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ShoppingCartService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/start-end-timepicker/start-end-timepicker.component.mjs

@@ -0,0 +1,126 @@
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@ohioepa/oepa-common-lib";
+import * as i3 from "@angular/common";
+import * as i4 from "ngx-bootstrap/timepicker";
+export class StartEndTimepickerComponent {
+    fb;
+    idService;
+    startComponentId = 'OepaTimepickerComponent';
+    endComponentId = 'OepaTimepickerComponent';
+    timeRangeInfo = {};
+    timeRangeInfoChange = new EventEmitter();
+    showValidation = false;
+    isRequired = false;
+    isReadOnly = false;
+    isDisabled = false;
+    defaultTimeRange = {};
+    offsetHours = 0;
+    form;
+    validStart = true;
+    validEnd = true;
+    constructor(fb, idService) {
+        this.fb = fb;
+        this.idService = idService;
+        this.form = this.fb.group({
+            start: null,
+            end: null
+        });
+        this.form.get("start")?.valueChanges.subscribe(time => {
+            if (this.validStart) {
+                let tmpTime = new Date(time);
+                tmpTime.setHours(time.getHours() - this.offsetHours);
+                this.timeRangeInfo.startHour = tmpTime.getHours();
+                this.timeRangeInfo.startMinute = tmpTime.getMinutes();
+                this.timeRangeInfo.startSecond = 0;
+            }
+            else {
+                this.timeRangeInfo.startHour = undefined;
+                this.timeRangeInfo.startMinute = undefined;
+                this.timeRangeInfo.startSecond = undefined;
+            }
+            this.timeRangeInfoChange.emit(this.timeRangeInfo);
+        });
+        this.form.get("end")?.valueChanges.subscribe(time => {
+            if (this.validEnd) {
+                let tmpTime = new Date(time);
+                tmpTime.setHours(time.getHours() - this.offsetHours);
+                this.timeRangeInfo.endHour = tmpTime.getHours();
+                this.timeRangeInfo.endMinute = tmpTime.getMinutes();
+                this.timeRangeInfo.endSecond = 0;
+            }
+            else {
+                this.timeRangeInfo.endHour = undefined;
+                this.timeRangeInfo.endMinute = undefined;
+                this.timeRangeInfo.endSecond = undefined;
+            }
+            this.timeRangeInfoChange.emit(this.timeRangeInfo);
+        });
+    }
+    isValidStart(event) {
+        this.validStart = event;
+    }
+    isValidEnd(event) {
+        this.validEnd = event;
+    }
+    ngOnInit() {
+        if (this.form) {
+            this.startComponentId = this.idService.getComponentId(this.form);
+            this.startComponentId += (this.startComponentId.length > 0 ? '_' : '') + ('StartTime');
+            this.endComponentId = this.idService.getComponentId(this.form);
+            this.endComponentId += (this.endComponentId.length > 0 ? '_' : '') + ('EndTime');
+        }
+        else {
+            console.log('OOPS No datepickerForm yet');
+        }
+        if (!this.timeRangeInfo.startHour && this.defaultTimeRange && this.defaultTimeRange.startHour) {
+            this.timeRangeInfo.startHour = this.defaultTimeRange.startHour;
+            this.timeRangeInfo.startMinute = this.defaultTimeRange.startMinute;
+            this.timeRangeInfo.startSecond = this.defaultTimeRange.startSecond;
+        }
+        if (!this.timeRangeInfo.endHour && this.defaultTimeRange && this.defaultTimeRange.endHour) {
+            this.timeRangeInfo.endHour = this.defaultTimeRange.endHour;
+            this.timeRangeInfo.endMinute = this.defaultTimeRange.endMinute;
+            this.timeRangeInfo.endSecond = this.defaultTimeRange.endSecond;
+        }
+        if (this.timeRangeInfo.startHour) {
+            this.form.patchValue({
+                start: this.setTime(this.timeRangeInfo.startHour, this.timeRangeInfo.startMinute || 0),
+            });
+        }
+        if (this.timeRangeInfo.endHour) {
+            this.form.patchValue({
+                end: this.setTime(this.timeRangeInfo.endHour, this.timeRangeInfo.endMinute || 0),
+            });
+        }
+    }
+    setTime(hour, minute) {
+        let date = new Date();
+        date.setHours(hour);
+        date.setMinutes(minute);
+        date.setSeconds(0);
+        return date;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StartEndTimepickerComponent, deps: [{ token: i1.FormBuilder }, { token: i2.OepaComponentIdService }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: StartEndTimepickerComponent, selector: "oepa-start-end-timepicker", inputs: { timeRangeInfo: "timeRangeInfo", showValidation: "showValidation", isRequired: "isRequired", isReadOnly: "isReadOnly", isDisabled: "isDisabled", defaultTimeRange: "defaultTimeRange" }, outputs: { timeRangeInfoChange: "timeRangeInfoChange" }, ngImport: i0, template: "<div [formGroup]=\"form\">\n  <div class=\"form-group row\">\n    <div class=\"col-sm-6\">\n      <div class=\"col-md-12 form-group\" [ngClass]=\"{'is-invalid':showValidation && isRequired && !validStart}\">\n        <div class=\"input-group\">\n          <timepicker formControlName=\"start\" [readonlyInput]=\"isReadOnly\" [id]=\"startComponentId+'_StartTime'\" [disabled]=\"isDisabled\" (isValid)=\"isValidStart($event)\"></timepicker>\n        </div>\n        <small class=\"help-block\" *ngIf=\"showValidation && isRequired && !validStart\">Time is invalid</small>\n      </div>\n    </div>\n    <div class=\"col-sm-6\">\n      <div class=\"col-md-12 form-group\" [ngClass]=\"{'is-invalid':showValidation && isRequired && !validEnd}\">\n        <div class=\"input-group\">\n          <timepicker formControlName=\"end\" [readonlyInput]=\"isReadOnly\" [id]=\"endComponentId+'_EndTime'\" [disabled]=\"isDisabled\" (isValid)=\"isValidEnd($event)\"></timepicker>\n        </div>\n        <small class=\"help-block\" *ngIf=\"showValidation && isRequired && !validEnd\">Time is invalid</small>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { 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.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i4.TimepickerComponent, selector: "timepicker", inputs: ["hourStep", "minuteStep", "secondsStep", "readonlyInput", "disabled", "mousewheel", "arrowkeys", "showSpinners", "showMeridian", "showMinutes", "showSeconds", "meridians", "min", "max", "hoursPlaceholder", "minutesPlaceholder", "secondsPlaceholder"], outputs: ["isValid", "meridianChange"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: StartEndTimepickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'oepa-start-end-timepicker', template: "<div [formGroup]=\"form\">\n  <div class=\"form-group row\">\n    <div class=\"col-sm-6\">\n      <div class=\"col-md-12 form-group\" [ngClass]=\"{'is-invalid':showValidation && isRequired && !validStart}\">\n        <div class=\"input-group\">\n          <timepicker formControlName=\"start\" [readonlyInput]=\"isReadOnly\" [id]=\"startComponentId+'_StartTime'\" [disabled]=\"isDisabled\" (isValid)=\"isValidStart($event)\"></timepicker>\n        </div>\n        <small class=\"help-block\" *ngIf=\"showValidation && isRequired && !validStart\">Time is invalid</small>\n      </div>\n    </div>\n    <div class=\"col-sm-6\">\n      <div class=\"col-md-12 form-group\" [ngClass]=\"{'is-invalid':showValidation && isRequired && !validEnd}\">\n        <div class=\"input-group\">\n          <timepicker formControlName=\"end\" [readonlyInput]=\"isReadOnly\" [id]=\"endComponentId+'_EndTime'\" [disabled]=\"isDisabled\" (isValid)=\"isValidEnd($event)\"></timepicker>\n        </div>\n        <small class=\"help-block\" *ngIf=\"showValidation && isRequired && !validEnd\">Time is invalid</small>\n      </div>\n    </div>\n  </div>\n</div>\n" }]
+        }], ctorParameters: () => [{ type: i1.FormBuilder }, { type: i2.OepaComponentIdService }], propDecorators: { timeRangeInfo: [{
+                type: Input
+            }], timeRangeInfoChange: [{
+                type: Output
+            }], showValidation: [{
+                type: Input
+            }], isRequired: [{
+                type: Input
+            }], isReadOnly: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input
+            }], defaultTimeRange: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"start-end-timepicker.component.js","sourceRoot":"","sources":["../../../../../projects/oepa-ui-lib/src/lib/start-end-timepicker/start-end-timepicker.component.ts","../../../../../projects/oepa-ui-lib/src/lib/start-end-timepicker/start-end-timepicker.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';\nimport { OepaComponentIdService } from '@ohioepa/oepa-common-lib';\nimport { TimeRange } from '@ohioepa/oepa-ebiz-lib';\nimport { FormBuilder, FormGroup } from '@angular/forms';\n\n@Component({\n  selector: 'oepa-start-end-timepicker',\n  templateUrl: './start-end-timepicker.component.html',\n  styleUrls: ['./start-end-timepicker.component.css']\n})\nexport class StartEndTimepickerComponent implements OnInit {\n  public startComponentId = 'OepaTimepickerComponent';\n  public endComponentId = 'OepaTimepickerComponent';\n\n  @Input() timeRangeInfo: TimeRange = {};\n  @Output() timeRangeInfoChange = new EventEmitter<TimeRange>();\n\n  @Input() showValidation = false;\n  @Input() isRequired = false;\n  @Input() isReadOnly = false;\n  @Input() isDisabled = false;\n  @Input() defaultTimeRange: TimeRange = {};\n\n  private offsetHours = 0;\n  public form: FormGroup;\n  validStart = true;\n  validEnd = true;\n\n  constructor(\n    private fb: FormBuilder,\n    private idService: OepaComponentIdService,\n  ) {\n    this.form = this.fb.group({\n      start: null,\n      end: null\n    });\n    \n    this.form.get(\"start\")?.valueChanges.subscribe(time => {\n      if(this.validStart) {\n        let tmpTime: Date = new Date(time);\n        tmpTime.setHours(time.getHours() - this.offsetHours);\n        this.timeRangeInfo.startHour = tmpTime.getHours();\n        this.timeRangeInfo.startMinute = tmpTime.getMinutes();\n        this.timeRangeInfo.startSecond = 0;\n      } else {\n        this.timeRangeInfo.startHour = undefined;\n        this.timeRangeInfo.startMinute = undefined;\n        this.timeRangeInfo.startSecond = undefined;\n      }\n      this.timeRangeInfoChange.emit(this.timeRangeInfo);\n    });\n    this.form.get(\"end\")?.valueChanges.subscribe(time => {\n      if(this.validEnd) {\n        let tmpTime: Date = new Date(time);\n        tmpTime.setHours(time.getHours() - this.offsetHours);\n        this.timeRangeInfo.endHour = tmpTime.getHours();\n        this.timeRangeInfo.endMinute = tmpTime.getMinutes();\n        this.timeRangeInfo.endSecond = 0;\n      } else {\n        this.timeRangeInfo.endHour = undefined;\n        this.timeRangeInfo.endMinute = undefined;\n        this.timeRangeInfo.endSecond = undefined;\n      }\n      this.timeRangeInfoChange.emit(this.timeRangeInfo);\n    });\n  }\n\n  isValidStart(event: boolean): void {\n    this.validStart = event;\n  }\n  isValidEnd(event: boolean): void {\n    this.validEnd = event;\n  }\n\n  ngOnInit() {\n    if (this.form) {\n      this.startComponentId = this.idService.getComponentId(this.form);\n      this.startComponentId += (this.startComponentId.length > 0 ? '_' : '') + ('StartTime');\n      this.endComponentId = this.idService.getComponentId(this.form);\n      this.endComponentId += (this.endComponentId.length > 0 ? '_' : '') + ('EndTime');\n    } else {\n      console.log('OOPS No datepickerForm yet');\n    }\n\n    if (!this.timeRangeInfo.startHour && this.defaultTimeRange && this.defaultTimeRange.startHour) {\n      this.timeRangeInfo.startHour = this.defaultTimeRange.startHour;\n      this.timeRangeInfo.startMinute = this.defaultTimeRange.startMinute;\n      this.timeRangeInfo.startSecond = this.defaultTimeRange.startSecond;\n    }\n    if (!this.timeRangeInfo.endHour && this.defaultTimeRange && this.defaultTimeRange.endHour) {\n      this.timeRangeInfo.endHour = this.defaultTimeRange.endHour;\n      this.timeRangeInfo.endMinute = this.defaultTimeRange.endMinute;\n      this.timeRangeInfo.endSecond = this.defaultTimeRange.endSecond;\n    }\n\n    if (this.timeRangeInfo.startHour) {\n      this.form.patchValue({\n        start: this.setTime(this.timeRangeInfo.startHour, this.timeRangeInfo.startMinute || 0),\n      });\n    }\n    if (this.timeRangeInfo.endHour) {\n      this.form.patchValue({\n        end: this.setTime(this.timeRangeInfo.endHour, this.timeRangeInfo.endMinute || 0),\n      });\n    }\n  }\n\n  setTime(hour: number, minute: number): Date {\n    let date = new Date();\n    date.setHours(hour);\n    date.setMinutes(minute);\n    date.setSeconds(0);\n    return date;\n  }\n\n}\n","<div [formGroup]=\"form\">\n  <div class=\"form-group row\">\n    <div class=\"col-sm-6\">\n      <div class=\"col-md-12 form-group\" [ngClass]=\"{'is-invalid':showValidation && isRequired && !validStart}\">\n        <div class=\"input-group\">\n          <timepicker formControlName=\"start\" [readonlyInput]=\"isReadOnly\" [id]=\"startComponentId+'_StartTime'\" [disabled]=\"isDisabled\" (isValid)=\"isValidStart($event)\"></timepicker>\n        </div>\n        <small class=\"help-block\" *ngIf=\"showValidation && isRequired && !validStart\">Time is invalid</small>\n      </div>\n    </div>\n    <div class=\"col-sm-6\">\n      <div class=\"col-md-12 form-group\" [ngClass]=\"{'is-invalid':showValidation && isRequired && !validEnd}\">\n        <div class=\"input-group\">\n          <timepicker formControlName=\"end\" [readonlyInput]=\"isReadOnly\" [id]=\"endComponentId+'_EndTime'\" [disabled]=\"isDisabled\" (isValid)=\"isValidEnd($event)\"></timepicker>\n        </div>\n        <small class=\"help-block\" *ngIf=\"showValidation && isRequired && !validEnd\">Time is invalid</small>\n      </div>\n    </div>\n  </div>\n</div>\n"]}

package/esm2022/lib/table/oepa-p-column.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2VwYS1wLWNvbHVtbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29lcGEtdWktbGliL3NyYy9saWIvdGFibGUvb2VwYS1wLWNvbHVtbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBPZXBhUENvbHVtbiB7XG4gICAgZmllbGQ6IHN0cmluZztcbiAgICBoZWFkZXI6IHN0cmluZztcbn0iXX0=

package/esm2022/lib/table/oepa-table-cell-classname.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class OepaTableCellClassnamePipe {
+    transform(row, column) {
+        let result = '';
+        row.cells.forEach((cell) => {
+            if (cell.id === column.id) {
+                result = cell.className;
+            }
+        });
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellClassnamePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellClassnamePipe, name: "cellClassname" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellClassnamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'cellClassname'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2VwYS10YWJsZS1jZWxsLWNsYXNzbmFtZS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvb2VwYS11aS1saWIvc3JjL2xpYi90YWJsZS9vZXBhLXRhYmxlLWNlbGwtY2xhc3NuYW1lLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBUXBELE1BQU0sT0FBTywwQkFBMEI7SUFDckMsU0FBUyxDQUFDLEdBQWlCLEVBQUUsTUFBdUI7UUFDbEQsSUFBSSxNQUFNLEdBQXVCLEVBQUUsQ0FBQztRQUNwQyxHQUFHLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQW1CLEVBQUUsRUFBRTtZQUN4QyxJQUFJLElBQUksQ0FBQyxFQUFFLEtBQUssTUFBTSxDQUFDLEVBQUUsRUFBRSxDQUFDO2dCQUMxQixNQUFNLEdBQUcsSUFBSSxDQUFDLFNBQVMsQ0FBQztZQUMxQixDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFDSCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO3dHQVRVLDBCQUEwQjtzR0FBMUIsMEJBQTBCOzs0RkFBMUIsMEJBQTBCO2tCQUh0QyxJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxlQUFlO2lCQUN0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgT2VwYVRhYmxlUm93IH0gZnJvbSBcIi4vb2VwYS10YWJsZS1yb3dcIjtcbmltcG9ydCB7IE9lcGFUYWJsZUNlbGwgfSBmcm9tIFwiLi9vZXBhLXRhYmxlLWNlbGxcIjtcbmltcG9ydCB7IE9lcGFUYWJsZUNvbHVtbiB9IGZyb20gXCIuL29lcGEtdGFibGUtY29sdW1uXCI7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2NlbGxDbGFzc25hbWUnXG59KVxuZXhwb3J0IGNsYXNzIE9lcGFUYWJsZUNlbGxDbGFzc25hbWVQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybShyb3c6IE9lcGFUYWJsZVJvdywgY29sdW1uOiBPZXBhVGFibGVDb2x1bW4pOiBzdHJpbmcge1xuICAgIGxldCByZXN1bHQ6IHN0cmluZyB8IHVuZGVmaW5lZCA9ICcnO1xuICAgIHJvdy5jZWxscy5mb3JFYWNoKChjZWxsOiBPZXBhVGFibGVDZWxsKSA9PiB7XG4gICAgICBpZiAoY2VsbC5pZCA9PT0gY29sdW1uLmlkKSB7XG4gICAgICAgIHJlc3VsdCA9IGNlbGwuY2xhc3NOYW1lO1xuICAgICAgfVxuICAgIH0pO1xuICAgIHJldHVybiByZXN1bHQ7XG4gIH1cbn0iXX0=

package/esm2022/lib/table/oepa-table-cell-click-event.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2VwYS10YWJsZS1jZWxsLWNsaWNrLWV2ZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvb2VwYS11aS1saWIvc3JjL2xpYi90YWJsZS9vZXBhLXRhYmxlLWNlbGwtY2xpY2stZXZlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9lcGFUYWJsZVJvdyB9IGZyb20gJy4vb2VwYS10YWJsZS1yb3cnO1xuZXhwb3J0IGludGVyZmFjZSBPZXBhVGFibGVDZWxsQ2xpY2tFdmVudCB7XG4gICAgLyoqXG4gICAgICogVGhlIGVudGlyZSByb3cgb2YgZGF0YSBmb3IgdGhlIGNlbGwgdGhhdCB3YXMgY2xpY2tlZC5cbiAgICAgKi9cbiAgICByb3c6IE9lcGFUYWJsZVJvdztcbiAgICAvKipcbiAgICAgKiBUaGUgY29sdW1uIGlkIGZvciB0aGUgY2VsbCB0aGF0IHdhcyBjbGlja2VkLlxuICAgICAqL1xuICAgIGNvbHVtbklkOiBzdHJpbmc7XG4gICAgLyoqXG4gICAgICogVGhlIHZhbHVlIG9mIHRoZSBjZWxsIHRoYXQgd2FzIGNsaWNrZWQuXG4gICAgICovXG4gICAgdmFsdWU6IGFueTtcbn1cbiJdfQ==

package/esm2022/lib/table/oepa-table-cell-colspan.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class OepaTableCellColSpanPipe {
+    transform(row, column) {
+        let result = 1;
+        row.cells.forEach((cell) => {
+            if (cell.id === column.id) {
+                result = cell.colSpan || 1;
+            }
+        });
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellColSpanPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellColSpanPipe, name: "cellColspan" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellColSpanPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'cellColspan'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2VwYS10YWJsZS1jZWxsLWNvbHNwYW4ucGlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29lcGEtdWktbGliL3NyYy9saWIvdGFibGUvb2VwYS10YWJsZS1jZWxsLWNvbHNwYW4ucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQzs7QUFRcEQsTUFBTSxPQUFPLHdCQUF3QjtJQUNqQyxTQUFTLENBQUMsR0FBaUIsRUFBRSxNQUF1QjtRQUNoRCxJQUFJLE1BQU0sR0FBVyxDQUFDLENBQUM7UUFDdkIsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFtQixFQUFFLEVBQUU7WUFDeEMsSUFBSSxJQUFJLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxFQUFFLEVBQUUsQ0FBQztnQkFDMUIsTUFBTSxHQUFHLElBQUksQ0FBQyxPQUFPLElBQUksQ0FBQyxDQUFDO1lBQzdCLENBQUM7UUFDSCxDQUFDLENBQUMsQ0FBQztRQUNILE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7d0dBVE0sd0JBQXdCO3NHQUF4Qix3QkFBd0I7OzRGQUF4Qix3QkFBd0I7a0JBSHBDLElBQUk7bUJBQUM7b0JBQ0YsSUFBSSxFQUFHLGFBQWE7aUJBQ3ZCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGlwZSwgUGlwZVRyYW5zZm9ybSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBPZXBhVGFibGVSb3cgfSBmcm9tIFwiLi9vZXBhLXRhYmxlLXJvd1wiO1xuaW1wb3J0IHsgT2VwYVRhYmxlQ2VsbCB9IGZyb20gXCIuL29lcGEtdGFibGUtY2VsbFwiO1xuaW1wb3J0IHsgT2VwYVRhYmxlQ29sdW1uIH0gZnJvbSBcIi4vb2VwYS10YWJsZS1jb2x1bW5cIjtcblxuQFBpcGUoeyBcbiAgICBuYW1lIDogJ2NlbGxDb2xzcGFuJ1xufSlcbmV4cG9ydCBjbGFzcyBPZXBhVGFibGVDZWxsQ29sU3BhblBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgICB0cmFuc2Zvcm0ocm93OiBPZXBhVGFibGVSb3csIGNvbHVtbjogT2VwYVRhYmxlQ29sdW1uKTogbnVtYmVyIHtcbiAgICAgICAgbGV0IHJlc3VsdDogbnVtYmVyID0gMTtcbiAgICAgICAgcm93LmNlbGxzLmZvckVhY2goKGNlbGw6IE9lcGFUYWJsZUNlbGwpID0+IHtcbiAgICAgICAgICBpZiAoY2VsbC5pZCA9PT0gY29sdW1uLmlkKSB7XG4gICAgICAgICAgICByZXN1bHQgPSBjZWxsLmNvbFNwYW4gfHwgMTtcbiAgICAgICAgICB9XG4gICAgICAgIH0pO1xuICAgICAgICByZXR1cm4gcmVzdWx0O1xuICAgICAgfVxufSJdfQ==

package/esm2022/lib/table/oepa-table-cell-hidden.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class OepaTableCellHiddenPipe {
+    transform(row, column) {
+        let hidden = false;
+        row.cells.forEach((cell) => {
+            if (cell.id === column.id) {
+                hidden = cell.hideValue || false;
+            }
+        });
+        return hidden;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellHiddenPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellHiddenPipe, name: "cellHidden" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellHiddenPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'cellHidden'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2VwYS10YWJsZS1jZWxsLWhpZGRlbi5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvb2VwYS11aS1saWIvc3JjL2xpYi90YWJsZS9vZXBhLXRhYmxlLWNlbGwtaGlkZGVuLnBpcGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBaUIsTUFBTSxlQUFlLENBQUM7O0FBUXBELE1BQU0sT0FBTyx1QkFBdUI7SUFDbEMsU0FBUyxDQUFDLEdBQWlCLEVBQUUsTUFBdUI7UUFDbEQsSUFBSSxNQUFNLEdBQVksS0FBSyxDQUFDO1FBQzVCLEdBQUcsQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBbUIsRUFBRSxFQUFFO1lBQ3hDLElBQUksSUFBSSxDQUFDLEVBQUUsS0FBSyxNQUFNLENBQUMsRUFBRSxFQUFFLENBQUM7Z0JBQzFCLE1BQU0sR0FBRyxJQUFJLENBQUMsU0FBUyxJQUFJLEtBQUssQ0FBQztZQUNuQyxDQUFDO1FBQ0gsQ0FBQyxDQUFDLENBQUM7UUFDSCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO3dHQVRVLHVCQUF1QjtzR0FBdkIsdUJBQXVCOzs0RkFBdkIsdUJBQXVCO2tCQUhuQyxJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxZQUFZO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgT2VwYVRhYmxlUm93IH0gZnJvbSBcIi4vb2VwYS10YWJsZS1yb3dcIjtcbmltcG9ydCB7IE9lcGFUYWJsZUNlbGwgfSBmcm9tIFwiLi9vZXBhLXRhYmxlLWNlbGxcIjtcbmltcG9ydCB7IE9lcGFUYWJsZUNvbHVtbiB9IGZyb20gXCIuL29lcGEtdGFibGUtY29sdW1uXCI7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2NlbGxIaWRkZW4nXG59KVxuZXhwb3J0IGNsYXNzIE9lcGFUYWJsZUNlbGxIaWRkZW5QaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybShyb3c6IE9lcGFUYWJsZVJvdywgY29sdW1uOiBPZXBhVGFibGVDb2x1bW4pOiBib29sZWFuIHtcbiAgICBsZXQgaGlkZGVuOiBib29sZWFuID0gZmFsc2U7XG4gICAgcm93LmNlbGxzLmZvckVhY2goKGNlbGw6IE9lcGFUYWJsZUNlbGwpID0+IHtcbiAgICAgIGlmIChjZWxsLmlkID09PSBjb2x1bW4uaWQpIHtcbiAgICAgICAgaGlkZGVuID0gY2VsbC5oaWRlVmFsdWUgfHwgZmFsc2U7XG4gICAgICB9XG4gICAgfSk7XG4gICAgcmV0dXJuIGhpZGRlbjtcbiAgfVxufSJdfQ==

package/esm2022/lib/table/oepa-table-cell-icon-classname.pipe.mjs

@@ -0,0 +1,22 @@
+import { Pipe } from "@angular/core";
+import * as i0 from "@angular/core";
+export class OepaTableCellIconClassnamePipe {
+    transform(row, column) {
+        let result = '';
+        row.cells.forEach((cell) => {
+            if (cell.id === column.id) {
+                result = cell.iconClassName;
+            }
+        });
+        return result;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellIconClassnamePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellIconClassnamePipe, name: "cellIconClassname" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: OepaTableCellIconClassnamePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'cellIconClassname'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib2VwYS10YWJsZS1jZWxsLWljb24tY2xhc3NuYW1lLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vZXBhLXVpLWxpYi9zcmMvbGliL3RhYmxlL29lcGEtdGFibGUtY2VsbC1pY29uLWNsYXNzbmFtZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQVFwRCxNQUFNLE9BQU8sOEJBQThCO0lBQ3pDLFNBQVMsQ0FBQyxHQUFpQixFQUFFLE1BQXVCO1FBQ2xELElBQUksTUFBTSxHQUF1QixFQUFFLENBQUM7UUFDcEMsR0FBRyxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFtQixFQUFFLEVBQUU7WUFDeEMsSUFBSSxJQUFJLENBQUMsRUFBRSxLQUFLLE1BQU0sQ0FBQyxFQUFFLEVBQUUsQ0FBQztnQkFDMUIsTUFBTSxHQUFHLElBQUksQ0FBQyxhQUFhLENBQUM7WUFDOUIsQ0FBQztRQUNILENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxNQUFNLENBQUM7SUFDaEIsQ0FBQzt3R0FUVSw4QkFBOEI7c0dBQTlCLDhCQUE4Qjs7NEZBQTlCLDhCQUE4QjtrQkFIMUMsSUFBSTttQkFBQztvQkFDSixJQUFJLEVBQUUsbUJBQW1CO2lCQUMxQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgT2VwYVRhYmxlUm93IH0gZnJvbSBcIi4vb2VwYS10YWJsZS1yb3dcIjtcbmltcG9ydCB7IE9lcGFUYWJsZUNlbGwgfSBmcm9tIFwiLi9vZXBhLXRhYmxlLWNlbGxcIjtcbmltcG9ydCB7IE9lcGFUYWJsZUNvbHVtbiB9IGZyb20gXCIuL29lcGEtdGFibGUtY29sdW1uXCI7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2NlbGxJY29uQ2xhc3NuYW1lJ1xufSlcbmV4cG9ydCBjbGFzcyBPZXBhVGFibGVDZWxsSWNvbkNsYXNzbmFtZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgdHJhbnNmb3JtKHJvdzogT2VwYVRhYmxlUm93LCBjb2x1bW46IE9lcGFUYWJsZUNvbHVtbik6IHN0cmluZyB7XG4gICAgbGV0IHJlc3VsdDogc3RyaW5nIHwgdW5kZWZpbmVkID0gJyc7XG4gICAgcm93LmNlbGxzLmZvckVhY2goKGNlbGw6IE9lcGFUYWJsZUNlbGwpID0+IHtcbiAgICAgIGlmIChjZWxsLmlkID09PSBjb2x1bW4uaWQpIHtcbiAgICAgICAgcmVzdWx0ID0gY2VsbC5pY29uQ2xhc3NOYW1lO1xuICAgICAgfVxuICAgIH0pO1xuICAgIHJldHVybiByZXN1bHQ7XG4gIH1cbn0iXX0=