@openmrs/ngx-formentry 3.0.1-pre.19

package/esm2015/form-entry/value-adapters/order.adapter.js

@@ -0,0 +1,186 @@
+import { Injectable } from '@angular/core';
+import * as _ from 'lodash';
+export class OrderValueAdapter {
+    constructor() {
+        this.formOrderNodes = [];
+        this.provider = '';
+    }
+    generateFormPayload(form) {
+        this.formOrderNodes = [];
+        this._setOrderProvider(form);
+        this._findTestOrderQuestionNodes(form.rootNode);
+        return this._createOrdersPayload(this.formOrderNodes, form);
+    }
+    populateForm(form, payload) {
+        form.existingOrders = payload;
+        this.formOrderNodes = [];
+        this._findTestOrderQuestionNodes(form.rootNode);
+        const existingOrders = this._getExistingOrders(form);
+        this._setOrderValues(this.formOrderNodes, existingOrders);
+    }
+    _setOrderProvider(form) {
+        if (form.valueProcessingInfo.providerUuid) {
+            this.provider = form.valueProcessingInfo.providerUuid;
+        }
+    }
+    _createOrdersPayload(orderNodes, form) {
+        const payload = [];
+        const selectedOrders = [];
+        let deletedOrders = [];
+        const existingOrders = this._getExistingOrders(form);
+        for (const orderNode of orderNodes) {
+            const orderNodeValues = orderNode.control.value;
+            const orders = [];
+            if (existingOrders) {
+                existingOrders.map(function (obj) {
+                    orders[obj.concept] = obj.concept;
+                });
+            }
+            for (const order in orderNodeValues) {
+                if (orderNodeValues.hasOwnProperty(order)) {
+                    const orderValue = orderNodeValues[order][orderNode.question.key];
+                    const payloadOrder = this._createPayloadOrder(orderValue, orderNode.question.extras);
+                    if (orders[orderValue] !== orderValue &&
+                        payloadOrder.concept !== '') {
+                        payload.push(payloadOrder);
+                    }
+                    selectedOrders[orderValue] = orderValue;
+                    if (payloadOrder.orderNumber === '') {
+                        delete payloadOrder.orderNumber;
+                    }
+                    if (payloadOrder.uuid === '') {
+                        delete payloadOrder.uuid;
+                    }
+                }
+            }
+        }
+        deletedOrders = this._getDeletedOrders(selectedOrders, existingOrders);
+        return this._addDeletedOrdersToPayload(deletedOrders, payload);
+    }
+    _getExistingOrders(form) {
+        if (form.existingOrders && form.existingOrders.orders) {
+            let existingOrders = form.existingOrders.orders.map((o) => {
+                return {
+                    concept: o.concept.uuid,
+                    orderNumber: o.orderNumber,
+                    orderUuid: o.uuid,
+                    voided: o.voided,
+                    dateVoided: o.auditInfo.dateVoided
+                };
+            });
+            return (existingOrders = _.filter(existingOrders, (order) => {
+                if (order.voided === true || order.dateVoided) {
+                    return false;
+                }
+                else {
+                    return true;
+                }
+            }));
+        }
+        else {
+            return;
+        }
+    }
+    _setOrderValues(node, existingOrders) {
+        this._findTestOrderQuestionNodes(node);
+        const orderNodes = this.formOrderNodes;
+        for (const orderNode of orderNodes) {
+            this._setOrderNodeValues(orderNode, existingOrders);
+        }
+    }
+    _addDeletedOrdersToPayload(deletedOrders, payload) {
+        for (const order in deletedOrders) {
+            if (deletedOrders.hasOwnProperty(order)) {
+                payload.push({ uuid: deletedOrders[order], voided: true });
+            }
+        }
+        return payload;
+    }
+    _createPayloadOrder(orderConcept, quesitonExtras) {
+        const order = {
+            concept: '',
+            type: '',
+            orderer: '',
+            careSetting: ''
+        };
+        order.concept = orderConcept;
+        order.type = quesitonExtras.questionOptions.orderType;
+        order.orderer = this.provider;
+        order.careSetting = quesitonExtras.questionOptions.orderSettingUuid;
+        // delete orderer if provider not provided
+        if (order.orderer === '') {
+            delete order.orderer;
+        }
+        return order;
+    }
+    _getDeletedOrders(selectedOrders, existingOrders) {
+        const deleteOrders = [];
+        if (selectedOrders) {
+            for (const order in existingOrders) {
+                if (existingOrders.hasOwnProperty(order)) {
+                    const existingOrderConcept = existingOrders[order].concept;
+                    const selectedOrder = selectedOrders[existingOrderConcept];
+                    if (selectedOrder !== existingOrderConcept) {
+                        deleteOrders.push(existingOrders[order].orderUuid);
+                    }
+                }
+            }
+        }
+        // console.log('Deleted Orders ', deleteOrders);
+        return deleteOrders;
+    }
+    _setOrderNodeValues(node, orders) {
+        let index = 0;
+        node['initialValue'] = orders;
+        for (const order of orders) {
+            node.createChildNode();
+            const value = {};
+            value[node.question.key] = order.concept;
+            const childNode = node.children[index];
+            childNode.control.setValue(value);
+            childNode['initialValue'] = value;
+            childNode['orderNumber'] = order.orderNumber;
+            // console.log('Set Value', node.children[index].control.value, node, childNode);
+            index++;
+        }
+    }
+    _findTestOrderQuestionNodes(formNode) {
+        if (formNode.children) {
+            if (formNode.children instanceof Object) {
+                for (const key in formNode.children) {
+                    if (formNode.children.hasOwnProperty(key)) {
+                        switch (formNode.children[key].question.renderingType) {
+                            case 'page':
+                                this._findTestOrderQuestionNodes(formNode.children[key]);
+                                break;
+                            case 'section':
+                                this._findTestOrderQuestionNodes(formNode.children[key]);
+                                break;
+                            case 'group':
+                                this._findTestOrderQuestionNodes(formNode.children[key]);
+                                break;
+                            case 'repeating':
+                                if (formNode.children) {
+                                    // eslint-disable-next-line guard-for-in
+                                    for (const node in formNode.children) {
+                                        const question = formNode.children[node].question;
+                                        if (question.extras &&
+                                            question.extras.type === 'testOrder') {
+                                            this.formOrderNodes.push(formNode.children[node]);
+                                        }
+                                    }
+                                }
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+OrderValueAdapter.decorators = [
+    { type: Injectable }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"order.adapter.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/form-entry/value-adapters/order.adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Form } from '../form-factory/form';\nimport { ValueAdapter } from './value.adapter';\nimport * as _ from 'lodash';\n@Injectable()\nexport class OrderValueAdapter implements ValueAdapter {\n  formOrderNodes = [];\n  private provider = '';\n\n  generateFormPayload(form: Form) {\n    this.formOrderNodes = [];\n    this._setOrderProvider(form);\n    this._findTestOrderQuestionNodes(form.rootNode);\n    return this._createOrdersPayload(this.formOrderNodes, form);\n  }\n\n  populateForm(form: Form, payload) {\n    form.existingOrders = payload;\n    this.formOrderNodes = [];\n    this._findTestOrderQuestionNodes(form.rootNode);\n    const existingOrders = this._getExistingOrders(form);\n    this._setOrderValues(this.formOrderNodes, existingOrders);\n  }\n\n  private _setOrderProvider(form: Form) {\n    if (form.valueProcessingInfo.providerUuid) {\n      this.provider = form.valueProcessingInfo.providerUuid;\n    }\n  }\n\n  private _createOrdersPayload(orderNodes, form: Form) {\n    const payload = [];\n    const selectedOrders = [];\n    let deletedOrders = [];\n    const existingOrders = this._getExistingOrders(form);\n    for (const orderNode of orderNodes) {\n      const orderNodeValues = orderNode.control.value;\n      const orders = [];\n      if (existingOrders) {\n        existingOrders.map(function (obj) {\n          orders[obj.concept] = obj.concept;\n        });\n      }\n\n      for (const order in orderNodeValues) {\n        if (orderNodeValues.hasOwnProperty(order)) {\n          const orderValue = orderNodeValues[order][orderNode.question.key];\n\n          const payloadOrder = this._createPayloadOrder(\n            orderValue,\n            orderNode.question.extras\n          );\n\n          if (\n            orders[orderValue] !== orderValue &&\n            payloadOrder.concept !== ''\n          ) {\n            payload.push(payloadOrder);\n          }\n          selectedOrders[orderValue] = orderValue;\n          if (payloadOrder.orderNumber === '') {\n            delete payloadOrder.orderNumber;\n          }\n          if (payloadOrder.uuid === '') {\n            delete payloadOrder.uuid;\n          }\n        }\n      }\n    }\n\n    deletedOrders = this._getDeletedOrders(selectedOrders, existingOrders);\n    return this._addDeletedOrdersToPayload(deletedOrders, payload);\n  }\n\n  private _getExistingOrders(form: Form) {\n    if (form.existingOrders && form.existingOrders.orders) {\n      let existingOrders = form.existingOrders.orders.map((o) => {\n        return {\n          concept: o.concept.uuid,\n          orderNumber: o.orderNumber,\n          orderUuid: o.uuid,\n          voided: o.voided,\n          dateVoided: o.auditInfo.dateVoided\n        };\n      });\n\n      return (existingOrders = _.filter(existingOrders, (order: any) => {\n        if (order.voided === true || order.dateVoided) {\n          return false;\n        } else {\n          return true;\n        }\n      }));\n    } else {\n      return;\n    }\n  }\n\n  private _setOrderValues(node, existingOrders) {\n    this._findTestOrderQuestionNodes(node);\n\n    const orderNodes = this.formOrderNodes;\n    for (const orderNode of orderNodes) {\n      this._setOrderNodeValues(orderNode, existingOrders);\n    }\n  }\n\n  private _addDeletedOrdersToPayload(deletedOrders, payload): any {\n    for (const order in deletedOrders) {\n      if (deletedOrders.hasOwnProperty(order)) {\n        payload.push({ uuid: deletedOrders[order], voided: true });\n      }\n    }\n    return payload;\n  }\n\n  private _createPayloadOrder(orderConcept, quesitonExtras): any {\n    const order = {\n      concept: '',\n      type: '',\n      orderer: '',\n      careSetting: ''\n    };\n    order.concept = orderConcept;\n    order.type = quesitonExtras.questionOptions.orderType;\n    order.orderer = this.provider;\n    order.careSetting = quesitonExtras.questionOptions.orderSettingUuid;\n\n    // delete orderer if provider not provided\n    if (order.orderer === '') {\n      delete order.orderer;\n    }\n\n    return order;\n  }\n\n  private _getDeletedOrders(selectedOrders, existingOrders): any {\n    const deleteOrders = [];\n    if (selectedOrders) {\n      for (const order in existingOrders) {\n        if (existingOrders.hasOwnProperty(order)) {\n          const existingOrderConcept = existingOrders[order].concept;\n          const selectedOrder = selectedOrders[existingOrderConcept];\n          if (selectedOrder !== existingOrderConcept) {\n            deleteOrders.push(existingOrders[order].orderUuid);\n          }\n        }\n      }\n    }\n    // console.log('Deleted Orders ', deleteOrders);\n    return deleteOrders;\n  }\n\n  private _setOrderNodeValues(node, orders) {\n    let index = 0;\n    node['initialValue'] = orders;\n    for (const order of orders) {\n      node.createChildNode();\n      const value = {};\n      value[node.question.key] = order.concept;\n      const childNode = node.children[index];\n      childNode.control.setValue(value);\n      childNode['initialValue'] = value;\n      childNode['orderNumber'] = order.orderNumber;\n      // console.log('Set Value', node.children[index].control.value, node, childNode);\n      index++;\n    }\n  }\n\n  private _findTestOrderQuestionNodes(formNode) {\n    if (formNode.children) {\n      if (formNode.children instanceof Object) {\n        for (const key in formNode.children) {\n          if (formNode.children.hasOwnProperty(key)) {\n            switch (formNode.children[key].question.renderingType) {\n              case 'page':\n                this._findTestOrderQuestionNodes(formNode.children[key]);\n                break;\n              case 'section':\n                this._findTestOrderQuestionNodes(formNode.children[key]);\n                break;\n              case 'group':\n                this._findTestOrderQuestionNodes(formNode.children[key]);\n\n                break;\n              case 'repeating':\n                if (formNode.children) {\n                  // eslint-disable-next-line guard-for-in\n                  for (const node in formNode.children) {\n                    const question = formNode.children[node].question;\n                    if (\n                      question.extras &&\n                      question.extras.type === 'testOrder'\n                    ) {\n                      this.formOrderNodes.push(formNode.children[node]);\n                    }\n                  }\n                }\n                break;\n              default:\n                break;\n            }\n          }\n        }\n      }\n    }\n  }\n}\n"]}

package/esm2015/form-entry/value-adapters/person-attribute.adapter.js

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import { NodeBase, GroupNode, ArrayNode } from '../form-factory/form-node';
+export class PersonAttribuAdapter {
+    constructor() { }
+    generateFormPayload(form) {
+        return this.generateNodePayload(form.rootNode);
+    }
+    generateNodePayload(rootNode) {
+        const nodes = this.getPersonAttributeNodes(rootNode);
+        const payload = [];
+        nodes.forEach((node) => {
+            if (node.control.value !== null &&
+                node.control.value !== undefined &&
+                node.control.value !== '' &&
+                node.initialValue !== node.control.value) {
+                if (node.question.extras.questionOptions.isSimpleValue === true) {
+                    payload.push({
+                        attributeType: node.question.extras.questionOptions.attributeType,
+                        value: node.control.value
+                    });
+                }
+                else {
+                    payload.push({
+                        attributeType: node.question.extras.questionOptions.attributeType,
+                        hydratedObject: node.control.value
+                    });
+                }
+            }
+        });
+        return payload;
+    }
+    populateForm(form, payload) {
+        this.populateNode(form.rootNode, payload);
+    }
+    populateNode(rootNode, payload) {
+        if (!Array.isArray(payload)) {
+            throw new Error('Expected an array of attributes');
+        }
+        const nodes = this.getPersonAttributeNodes(rootNode);
+        nodes.forEach((node) => {
+            payload.forEach((element) => {
+                if (element.attributeType.uuid ===
+                    node.question.extras.questionOptions.attributeType) {
+                    if (element.value.uuid) {
+                        node.control.setValue(element.value.uuid);
+                        node.initialValue = element.value.uuid;
+                    }
+                    else {
+                        node.control.setValue(element.value);
+                        node.initialValue = element.value;
+                    }
+                }
+            });
+        });
+    }
+    getPersonAttributeNodes(rootNode) {
+        const results = [];
+        this._getPersonAttributesNodes(rootNode, results);
+        return results;
+    }
+    _getPersonAttributesNodes(rootNode, array) {
+        if (rootNode.question.extras &&
+            rootNode.question.extras.type === 'personAttribute') {
+            array.push(rootNode);
+        }
+        if (rootNode instanceof GroupNode) {
+            const node = rootNode;
+            // eslint-disable-next-line guard-for-in
+            for (const o in node.children) {
+                if (node.children[o] instanceof NodeBase) {
+                    this._getPersonAttributesNodes(node.children[o], array);
+                }
+            }
+        }
+        if (rootNode instanceof ArrayNode) {
+            const node = rootNode;
+            node.children.forEach((child) => {
+                this._getPersonAttributesNodes(child, array);
+            });
+        }
+    }
+}
+PersonAttribuAdapter.decorators = [
+    { type: Injectable }
+];
+PersonAttribuAdapter.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/form-entry/value-adapters/value.adapter.js

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

package/esm2015/lib/index.js

@@ -0,0 +1,49 @@
+/*
+ * Public API Surface of ngx-formentry
+ */
+export { FormEntryModule } from '../form-entry/form-entry.module';
+export { AfeFormControl } from '../abstract-controls-extension/afe-form-control';
+export { AfeFormGroup } from '../abstract-controls-extension/afe-form-group';
+export { AfeFormArray } from '../abstract-controls-extension/afe-form-array';
+export { AfeControlType } from '../abstract-controls-extension/afe-control-type';
+export { ControlRelationsFactory } from '../form-entry/form-factory/control-relations.factory';
+export { FormControlService } from '../form-entry/form-factory/form-control.service';
+export { FormFactory } from '../form-entry/form-factory/form.factory';
+export { Form } from '../form-entry/form-factory/form';
+export { QuestionFactory } from '../form-entry/form-factory/question.factory';
+export { ValidationFactory } from '../form-entry/form-factory/validation.factory';
+export { FormSchemaCompiler } from '../form-entry/services/form-schema-compiler.service';
+export { HistoricalEncounterDataService } from '../form-entry/services/historical-encounter-data.service';
+export { FormErrorsService } from '../form-entry/services/form-errors.service';
+export { EncounterAdapter } from '../form-entry/value-adapters/encounter.adapter';
+export { PersonAttribuAdapter } from '../form-entry/value-adapters/person-attribute.adapter';
+export { OrderValueAdapter } from '../form-entry/value-adapters/order.adapter';
+export { ObsValueAdapter } from '../form-entry/value-adapters/obs.adapter';
+export { ObsAdapterHelper } from '../form-entry/value-adapters/obs-adapter-helper';
+export { DataSources } from '../form-entry/data-sources/data-sources';
+export { CheckBoxQuestion } from '../form-entry/question-models/checkbox.model';
+export { ConditionalValidationModel } from '../form-entry/question-models/conditional-validation.model';
+export { DateQuestion } from '../form-entry/question-models/date-question';
+export { DateValidationModel } from '../form-entry/question-models/date-validation.model';
+export { FileUploadQuestion } from '../form-entry/question-models/file-upload-question';
+export { QuestionGroup } from '../form-entry/question-models/group-question';
+export { JsExpressionValidationModel } from '../form-entry/question-models/js-expression-validation.model';
+export { MaxValidationModel } from '../form-entry/question-models/max-validation.model';
+export { MinValidationModel } from '../form-entry/question-models/min-validation.model';
+export { MultiSelectQuestion } from '../form-entry/question-models/multi-select-question';
+export { Pair } from '../form-entry/question-models/pair.model';
+export { QuestionBase } from '../form-entry/question-models/question-base';
+export { RenderingType } from '../form-entry/question-models/rendering-type';
+export { RepeatingQuestion } from '../form-entry/question-models/repeating-question';
+export { Option } from '../form-entry/question-models/select-option';
+export { SelectQuestion } from '../form-entry/question-models/select-question';
+export { TestOrderQuestion } from '../form-entry/question-models/test-order-question';
+export { TextAreaInputQuestion } from '../form-entry/question-models/text-area-input-question';
+export { TextInputQuestion } from '../form-entry/question-models/text-input-question';
+export { UiSelectQuestion } from '../form-entry/question-models/ui-select-question';
+export { ValidationModel } from '../form-entry/question-models/validation.model';
+export { NestedQuestion } from '../form-entry/question-models/interfaces/nested-questions';
+export { DateTimePickerModule } from '../components/date-time-picker/date-time-picker.module';
+export { NgxDateTimePickerModule } from '../components/ngx-datetime-picker/ngx-datetime-picker.module';
+export { JsExpressionHelper } from '../form-entry/helpers/js-expression-helper';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../projects/ngx-formentry/src/lib/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAC;AAC7E,OAAO,EAAE,YAAY,EAAE,MAAM,+CAA+C,CAAC;AAC7E,OAAO,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AACjF,OAAO,EAAE,uBAAuB,EAAE,MAAM,sDAAsD,CAAC;AAC/F,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAE,IAAI,EAAE,MAAM,iCAAiC,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,6CAA6C,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,+CAA+C,CAAC;AAClF,OAAO,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAC;AACzF,OAAO,EAAE,8BAA8B,EAAE,MAAM,0DAA0D,CAAC;AAC1G,OAAO,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAC;AAC/E,OAAO,EAAE,gBAAgB,EAAE,MAAM,gDAAgD,CAAC;AAClF,OAAO,EAAE,oBAAoB,EAAE,MAAM,uDAAuD,CAAC;AAC7F,OAAO,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAC;AAC/E,OAAO,EAAE,eAAe,EAAE,MAAM,0CAA0C,CAAC;AAC3E,OAAO,EAAE,gBAAgB,EAAE,MAAM,iDAAiD,CAAC;AAEnF,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAChF,OAAO,EAAE,0BAA0B,EAAE,MAAM,4DAA4D,CAAC;AACxG,OAAO,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAC3E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAC1F,OAAO,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AACxF,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAC7E,OAAO,EAAE,2BAA2B,EAAE,MAAM,8DAA8D,CAAC;AAC3G,OAAO,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,MAAM,oDAAoD,CAAC;AACxF,OAAO,EAAE,mBAAmB,EAAE,MAAM,qDAAqD,CAAC;AAC1F,OAAO,EAAE,IAAI,EAAE,MAAM,0CAA0C,CAAC;AAChE,OAAO,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAC3E,OAAO,EAAE,aAAa,EAAE,MAAM,8CAA8C,CAAC;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,kDAAkD,CAAC;AACrF,OAAO,EAAE,MAAM,EAAE,MAAM,6CAA6C,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,MAAM,mDAAmD,CAAC;AACtF,OAAO,EAAE,qBAAqB,EAAE,MAAM,wDAAwD,CAAC;AAC/F,OAAO,EAAE,iBAAiB,EAAE,MAAM,mDAAmD,CAAC;AACtF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kDAAkD,CAAC;AACpF,OAAO,EAAE,eAAe,EAAE,MAAM,gDAAgD,CAAC;AAIjF,OAAO,EAAE,cAAc,EAAE,MAAM,2DAA2D,CAAC;AAC3F,OAAO,EAAE,oBAAoB,EAAE,MAAM,wDAAwD,CAAC;AAC9F,OAAO,EAAE,uBAAuB,EAAE,MAAM,8DAA8D,CAAC;AACvG,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC","sourcesContent":["/*\n * Public API Surface of ngx-formentry\n */\nexport { FormEntryModule } from '../form-entry/form-entry.module';\nexport { AfeFormControl } from '../abstract-controls-extension/afe-form-control';\nexport { AfeFormGroup } from '../abstract-controls-extension/afe-form-group';\nexport { AfeFormArray } from '../abstract-controls-extension/afe-form-array';\nexport { AfeControlType } from '../abstract-controls-extension/afe-control-type';\nexport { ControlRelationsFactory } from '../form-entry/form-factory/control-relations.factory';\nexport { FormControlService } from '../form-entry/form-factory/form-control.service';\nexport { FormFactory } from '../form-entry/form-factory/form.factory';\nexport { Form } from '../form-entry/form-factory/form';\nexport { QuestionFactory } from '../form-entry/form-factory/question.factory';\nexport { ValidationFactory } from '../form-entry/form-factory/validation.factory';\nexport { FormSchemaCompiler } from '../form-entry/services/form-schema-compiler.service';\nexport { HistoricalEncounterDataService } from '../form-entry/services/historical-encounter-data.service';\nexport { FormErrorsService } from '../form-entry/services/form-errors.service';\nexport { EncounterAdapter } from '../form-entry/value-adapters/encounter.adapter';\nexport { PersonAttribuAdapter } from '../form-entry/value-adapters/person-attribute.adapter';\nexport { OrderValueAdapter } from '../form-entry/value-adapters/order.adapter';\nexport { ObsValueAdapter } from '../form-entry/value-adapters/obs.adapter';\nexport { ObsAdapterHelper } from '../form-entry/value-adapters/obs-adapter-helper';\nexport { ValueAdapter } from '../form-entry/value-adapters/value.adapter';\nexport { DataSources } from '../form-entry/data-sources/data-sources';\nexport { CheckBoxQuestion } from '../form-entry/question-models/checkbox.model';\nexport { ConditionalValidationModel } from '../form-entry/question-models/conditional-validation.model';\nexport { DateQuestion } from '../form-entry/question-models/date-question';\nexport { DateValidationModel } from '../form-entry/question-models/date-validation.model';\nexport { FileUploadQuestion } from '../form-entry/question-models/file-upload-question';\nexport { QuestionGroup } from '../form-entry/question-models/group-question';\nexport { JsExpressionValidationModel } from '../form-entry/question-models/js-expression-validation.model';\nexport { MaxValidationModel } from '../form-entry/question-models/max-validation.model';\nexport { MinValidationModel } from '../form-entry/question-models/min-validation.model';\nexport { MultiSelectQuestion } from '../form-entry/question-models/multi-select-question';\nexport { Pair } from '../form-entry/question-models/pair.model';\nexport { QuestionBase } from '../form-entry/question-models/question-base';\nexport { RenderingType } from '../form-entry/question-models/rendering-type';\nexport { RepeatingQuestion } from '../form-entry/question-models/repeating-question';\nexport { Option } from '../form-entry/question-models/select-option';\nexport { SelectQuestion } from '../form-entry/question-models/select-question';\nexport { TestOrderQuestion } from '../form-entry/question-models/test-order-question';\nexport { TextAreaInputQuestion } from '../form-entry/question-models/text-area-input-question';\nexport { TextInputQuestion } from '../form-entry/question-models/text-input-question';\nexport { UiSelectQuestion } from '../form-entry/question-models/ui-select-question';\nexport { ValidationModel } from '../form-entry/question-models/validation.model';\nexport { BaseOptions } from '../form-entry/question-models/interfaces/base-options';\nexport { RepeatingQuestionOptions } from '../form-entry/question-models/interfaces/repeating-question-options';\nexport { GroupQuestionOptions } from '../form-entry/question-models/interfaces/group-question-options';\nexport { NestedQuestion } from '../form-entry/question-models/interfaces/nested-questions';\nexport { DateTimePickerModule } from '../components/date-time-picker/date-time-picker.module';\nexport { NgxDateTimePickerModule } from '../components/ngx-datetime-picker/ngx-datetime-picker.module';\nexport { JsExpressionHelper } from '../form-entry/helpers/js-expression-helper';\n"]}

package/esm2015/openmrs-ngx-formentry.js

@@ -0,0 +1,76 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+export { AfeNgSelectComponent as ɵcw } from './components/afe-ng-select.component';
+export { AppointmentsOverviewComponent as ɵcx } from './components/appointments-overview/appointments-overview.component';
+export { CheckboxControlComponent as ɵw } from './components/check-box/checkbox.component';
+export { CheckboxModule as ɵv } from './components/check-box/checkbox.module';
+export { CustomComponentWrapperModule as ɵco } from './components/custom-component-wrapper/custom-component-wrapper..module';
+export { CustomComponentWrapperComponent as ɵcp } from './components/custom-component-wrapper/custom-component-wrapper.component';
+export { CustomControlWrapperModule as ɵcm } from './components/custom-control-wrapper/custom-control-wrapper..module';
+export { CustomControlWrapperComponent as ɵcn } from './components/custom-control-wrapper/custom-control-wrapper.component';
+export { DatePickerComponent as ɵk } from './components/date-time-picker/date-picker/date-picker.component';
+export { DateTimePickerComponent as ɵo } from './components/date-time-picker/date-time-picker.component';
+export { ModalComponent as ɵm } from './components/date-time-picker/picker-modal/modal.component';
+export { MomentPipe as ɵn } from './components/date-time-picker/pipes/moment.pipe';
+export { TimePickerComponent as ɵl } from './components/date-time-picker/time-picker/time-picker.component';
+export { FileUploadComponent as ɵu } from './components/file-upload/file-upload.component';
+export { RemoteFileUploadModule as ɵr } from './components/file-upload/file-upload.module';
+export { SecurePipe as ɵt } from './components/file-upload/secure.pipe';
+export { TextInput as ɵj } from './components/input/input.directive';
+export { InputModule as ɵg } from './components/input/input.module';
+export { Label as ɵh } from './components/input/label.component';
+export { TextArea as ɵi } from './components/input/text-area.directive';
+export { NgxDatetimeComponent as ɵcl } from './components/ngx-datetime-picker/ngx-datetime-picker.component';
+export { DateTimeAdapter as ɵbm, OWL_DATE_TIME_LOCALE as ɵbk, OWL_DATE_TIME_LOCALE_FACTORY as ɵbl } from './components/ngx-pick-datetime/lib/date-time/adapter/date-time-adapter.class';
+export { OWL_DATE_TIME_FORMATS as ɵbi } from './components/ngx-pick-datetime/lib/date-time/adapter/date-time-format.class';
+export { NativeDateTimeAdapter as ɵcj } from './components/ngx-pick-datetime/lib/date-time/adapter/native-date-time-adapter.class';
+export { OWL_NATIVE_DATE_TIME_FORMATS as ɵck } from './components/ngx-pick-datetime/lib/date-time/adapter/native-date-time-format.class';
+export { NativeDateTimeModule as ɵch, OwlNativeDateTimeModule as ɵci } from './components/ngx-pick-datetime/lib/date-time/adapter/native-date-time.module';
+export { OwlCalendarBodyComponent as ɵcc } from './components/ngx-pick-datetime/lib/date-time/calendar-body.component';
+export { OwlMonthViewComponent as ɵce } from './components/ngx-pick-datetime/lib/date-time/calendar-month-view.component';
+export { OwlMultiYearViewComponent as ɵcb } from './components/ngx-pick-datetime/lib/date-time/calendar-multi-year-view.component';
+export { OwlYearViewComponent as ɵcd } from './components/ngx-pick-datetime/lib/date-time/calendar-year-view.component';
+export { OwlCalendarComponent as ɵbg } from './components/ngx-pick-datetime/lib/date-time/calendar.component';
+export { OWL_DATETIME_VALUE_ACCESSOR as ɵbx, OwlDateTimeInlineComponent as ɵby } from './components/ngx-pick-datetime/lib/date-time/date-time-inline.component';
+export { OwlDateTimeContainerComponent as ɵbz } from './components/ngx-pick-datetime/lib/date-time/date-time-picker-container.component';
+export { OWL_DATETIME_VALIDATORS as ɵbq, OWL_DATETIME_VALUE_ACCESSOR as ɵbp, OwlDateTimeInputDirective as ɵbr } from './components/ngx-pick-datetime/lib/date-time/date-time-picker-input.directive';
+export { OwlDateTimeIntl as ɵbj } from './components/ngx-pick-datetime/lib/date-time/date-time-picker-intl.service';
+export { OwlDateTimeTriggerDirective as ɵbo } from './components/ngx-pick-datetime/lib/date-time/date-time-picker-trigger.directive';
+export { owlDateTimePickerAnimations as ɵca } from './components/ngx-pick-datetime/lib/date-time/date-time-picker.animations';
+export { OWL_DTPICKER_SCROLL_STRATEGY as ɵbs, OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER as ɵbu, OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵbt, OwlDateTimeComponent as ɵbv } from './components/ngx-pick-datetime/lib/date-time/date-time-picker.component';
+export { OwlDateTime as ɵbw } from './components/ngx-pick-datetime/lib/date-time/date-time.class';
+export { OwlDateTimeModule as ɵx } from './components/ngx-pick-datetime/lib/date-time/date-time.module';
+export { NumberFixedLenPipe as ɵcg } from './components/ngx-pick-datetime/lib/date-time/numberedFixLen.pipe';
+export { OwlTimerBoxComponent as ɵcf } from './components/ngx-pick-datetime/lib/date-time/timer-box.component';
+export { OwlTimerComponent as ɵbn } from './components/ngx-pick-datetime/lib/date-time/timer.component';
+export { OwlDialogConfig as ɵbf } from './components/ngx-pick-datetime/lib/dialog/dialog-config.class';
+export { OwlDialogContainerComponent as ɵz } from './components/ngx-pick-datetime/lib/dialog/dialog-container.component';
+export { OwlDialogModule as ɵy } from './components/ngx-pick-datetime/lib/dialog/dialog.module';
+export { OWL_DIALOG_DEFAULT_OPTIONS as ɵbd, OWL_DIALOG_SCROLL_STRATEGY as ɵba, OWL_DIALOG_SCROLL_STRATEGY_PROVIDER as ɵbc, OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵbb, OwlDialogService as ɵbe } from './components/ngx-pick-datetime/lib/dialog/dialog.service';
+export { RemoteSelectComponent as ɵq } from './components/ngx-remote-select/ngx-remote-select.component';
+export { NgxRemoteSelectModule as ɵp } from './components/ngx-remote-select/ngx-remote-select.module';
+export { TabComponent as ɵcr } from './components/ngx-tabset/components/tab';
+export { TabsetComponent as ɵcs } from './components/ngx-tabset/components/tab-set';
+export { HoverClassDirective as ɵct } from './components/ngx-tabset/directives/hover-class.directive';
+export { NgxTabSetModule as ɵcq } from './components/ngx-tabset/modules/ngx-tabset.module';
+export { NumberInputComponent as ɵf } from './components/number-input/number-input.component';
+export { NumberInputModule as ɵe } from './components/number-input/number-input.module';
+export { OptGroup as ɵd } from './components/select/optgroup.directive';
+export { Option as ɵc } from './components/select/option.directive';
+export { Select as ɵb } from './components/select/select.component';
+export { SelectModule as ɵa } from './components/select/select.module';
+export { CollapseDirective as ɵdc } from './form-entry/directives/collapse.directive';
+export { HistoricalValueDirective as ɵcy } from './form-entry/directives/historical-value-directive';
+export { ErrorRendererComponent as ɵda } from './form-entry/error-renderer/error-renderer.component';
+export { ExpressionRunner as ɵde } from './form-entry/expression-runner/expression-runner';
+export { HidersDisablersFactory as ɵdd } from './form-entry/form-factory/hiders-disablers.factory';
+export { AlertsFactory as ɵdg } from './form-entry/form-factory/show-messages.factory';
+export { FormRendererComponent as ɵcu } from './form-entry/form-renderer/form-renderer.component';
+export { DEFAULT_STYLES as ɵcv } from './form-entry/form-renderer/form-renderer.component.css';
+export { HistoricalFieldHelperService as ɵcz } from './form-entry/helpers/historical-field-helper-service';
+export { TimeAgoPipe as ɵdb } from './form-entry/pipes/time-ago.pipe';
+export { DebugModeService as ɵdf } from './form-entry/services/debug-mode.service';
+export { SharedModule as ɵs } from './shared.module';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openmrs-ngx-formentry.js","sourceRoot":"","sources":["../../../projects/ngx-formentry/src/openmrs-ngx-formentry.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public_api';\n\nexport {AfeNgSelectComponent as ɵcw} from './components/afe-ng-select.component';\nexport {AppointmentsOverviewComponent as ɵcx} from './components/appointments-overview/appointments-overview.component';\nexport {CheckboxControlComponent as ɵw} from './components/check-box/checkbox.component';\nexport {CheckboxModule as ɵv} from './components/check-box/checkbox.module';\nexport {CustomComponentWrapperModule as ɵco} from './components/custom-component-wrapper/custom-component-wrapper..module';\nexport {CustomComponentWrapperComponent as ɵcp} from './components/custom-component-wrapper/custom-component-wrapper.component';\nexport {CustomControlWrapperModule as ɵcm} from './components/custom-control-wrapper/custom-control-wrapper..module';\nexport {CustomControlWrapperComponent as ɵcn} from './components/custom-control-wrapper/custom-control-wrapper.component';\nexport {DatePickerComponent as ɵk} from './components/date-time-picker/date-picker/date-picker.component';\nexport {DateTimePickerComponent as ɵo} from './components/date-time-picker/date-time-picker.component';\nexport {ModalComponent as ɵm} from './components/date-time-picker/picker-modal/modal.component';\nexport {MomentPipe as ɵn} from './components/date-time-picker/pipes/moment.pipe';\nexport {TimePickerComponent as ɵl} from './components/date-time-picker/time-picker/time-picker.component';\nexport {FileUploadComponent as ɵu} from './components/file-upload/file-upload.component';\nexport {RemoteFileUploadModule as ɵr} from './components/file-upload/file-upload.module';\nexport {SecurePipe as ɵt} from './components/file-upload/secure.pipe';\nexport {TextInput as ɵj} from './components/input/input.directive';\nexport {InputModule as ɵg} from './components/input/input.module';\nexport {Label as ɵh} from './components/input/label.component';\nexport {TextArea as ɵi} from './components/input/text-area.directive';\nexport {NgxDatetimeComponent as ɵcl} from './components/ngx-datetime-picker/ngx-datetime-picker.component';\nexport {DateTimeAdapter as ɵbm,OWL_DATE_TIME_LOCALE as ɵbk,OWL_DATE_TIME_LOCALE_FACTORY as ɵbl} from './components/ngx-pick-datetime/lib/date-time/adapter/date-time-adapter.class';\nexport {OWL_DATE_TIME_FORMATS as ɵbi,OwlDateTimeFormats as ɵbh} from './components/ngx-pick-datetime/lib/date-time/adapter/date-time-format.class';\nexport {NativeDateTimeAdapter as ɵcj} from './components/ngx-pick-datetime/lib/date-time/adapter/native-date-time-adapter.class';\nexport {OWL_NATIVE_DATE_TIME_FORMATS as ɵck} from './components/ngx-pick-datetime/lib/date-time/adapter/native-date-time-format.class';\nexport {NativeDateTimeModule as ɵch,OwlNativeDateTimeModule as ɵci} from './components/ngx-pick-datetime/lib/date-time/adapter/native-date-time.module';\nexport {OwlCalendarBodyComponent as ɵcc} from './components/ngx-pick-datetime/lib/date-time/calendar-body.component';\nexport {OwlMonthViewComponent as ɵce} from './components/ngx-pick-datetime/lib/date-time/calendar-month-view.component';\nexport {OwlMultiYearViewComponent as ɵcb} from './components/ngx-pick-datetime/lib/date-time/calendar-multi-year-view.component';\nexport {OwlYearViewComponent as ɵcd} from './components/ngx-pick-datetime/lib/date-time/calendar-year-view.component';\nexport {OwlCalendarComponent as ɵbg} from './components/ngx-pick-datetime/lib/date-time/calendar.component';\nexport {OWL_DATETIME_VALUE_ACCESSOR as ɵbx,OwlDateTimeInlineComponent as ɵby} from './components/ngx-pick-datetime/lib/date-time/date-time-inline.component';\nexport {OwlDateTimeContainerComponent as ɵbz} from './components/ngx-pick-datetime/lib/date-time/date-time-picker-container.component';\nexport {OWL_DATETIME_VALIDATORS as ɵbq,OWL_DATETIME_VALUE_ACCESSOR as ɵbp,OwlDateTimeInputDirective as ɵbr} from './components/ngx-pick-datetime/lib/date-time/date-time-picker-input.directive';\nexport {OwlDateTimeIntl as ɵbj} from './components/ngx-pick-datetime/lib/date-time/date-time-picker-intl.service';\nexport {OwlDateTimeTriggerDirective as ɵbo} from './components/ngx-pick-datetime/lib/date-time/date-time-picker-trigger.directive';\nexport {owlDateTimePickerAnimations as ɵca} from './components/ngx-pick-datetime/lib/date-time/date-time-picker.animations';\nexport {OWL_DTPICKER_SCROLL_STRATEGY as ɵbs,OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER as ɵbu,OWL_DTPICKER_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵbt,OwlDateTimeComponent as ɵbv} from './components/ngx-pick-datetime/lib/date-time/date-time-picker.component';\nexport {OwlDateTime as ɵbw} from './components/ngx-pick-datetime/lib/date-time/date-time.class';\nexport {OwlDateTimeModule as ɵx} from './components/ngx-pick-datetime/lib/date-time/date-time.module';\nexport {NumberFixedLenPipe as ɵcg} from './components/ngx-pick-datetime/lib/date-time/numberedFixLen.pipe';\nexport {OwlTimerBoxComponent as ɵcf} from './components/ngx-pick-datetime/lib/date-time/timer-box.component';\nexport {OwlTimerComponent as ɵbn} from './components/ngx-pick-datetime/lib/date-time/timer.component';\nexport {OwlDialogConfig as ɵbf} from './components/ngx-pick-datetime/lib/dialog/dialog-config.class';\nexport {OwlDialogContainerComponent as ɵz} from './components/ngx-pick-datetime/lib/dialog/dialog-container.component';\nexport {OwlDialogModule as ɵy} from './components/ngx-pick-datetime/lib/dialog/dialog.module';\nexport {OWL_DIALOG_DEFAULT_OPTIONS as ɵbd,OWL_DIALOG_SCROLL_STRATEGY as ɵba,OWL_DIALOG_SCROLL_STRATEGY_PROVIDER as ɵbc,OWL_DIALOG_SCROLL_STRATEGY_PROVIDER_FACTORY as ɵbb,OwlDialogService as ɵbe} from './components/ngx-pick-datetime/lib/dialog/dialog.service';\nexport {RemoteSelectComponent as ɵq} from './components/ngx-remote-select/ngx-remote-select.component';\nexport {NgxRemoteSelectModule as ɵp} from './components/ngx-remote-select/ngx-remote-select.module';\nexport {TabComponent as ɵcr} from './components/ngx-tabset/components/tab';\nexport {TabsetComponent as ɵcs} from './components/ngx-tabset/components/tab-set';\nexport {HoverClassDirective as ɵct} from './components/ngx-tabset/directives/hover-class.directive';\nexport {NgxTabSetModule as ɵcq} from './components/ngx-tabset/modules/ngx-tabset.module';\nexport {NumberInputComponent as ɵf} from './components/number-input/number-input.component';\nexport {NumberInputModule as ɵe} from './components/number-input/number-input.module';\nexport {OptGroup as ɵd} from './components/select/optgroup.directive';\nexport {Option as ɵc} from './components/select/option.directive';\nexport {Select as ɵb} from './components/select/select.component';\nexport {SelectModule as ɵa} from './components/select/select.module';\nexport {CollapseDirective as ɵdc} from './form-entry/directives/collapse.directive';\nexport {HistoricalValueDirective as ɵcy} from './form-entry/directives/historical-value-directive';\nexport {ErrorRendererComponent as ɵda} from './form-entry/error-renderer/error-renderer.component';\nexport {ExpressionRunner as ɵde} from './form-entry/expression-runner/expression-runner';\nexport {HidersDisablersFactory as ɵdd} from './form-entry/form-factory/hiders-disablers.factory';\nexport {AlertsFactory as ɵdg} from './form-entry/form-factory/show-messages.factory';\nexport {FormRendererComponent as ɵcu} from './form-entry/form-renderer/form-renderer.component';\nexport {DEFAULT_STYLES as ɵcv} from './form-entry/form-renderer/form-renderer.component.css';\nexport {HistoricalFieldHelperService as ɵcz} from './form-entry/helpers/historical-field-helper-service';\nexport {TimeAgoPipe as ɵdb} from './form-entry/pipes/time-ago.pipe';\nexport {CheckboxOptions as ɵdh} from './form-entry/question-models/interfaces/checkbox-options';\nexport {DateQuestionOptions as ɵdi} from './form-entry/question-models/interfaces/date-question-options';\nexport {FileUploadQuestionOptions as ɵdj} from './form-entry/question-models/interfaces/file-upload-question-options';\nexport {MultiSelectQuestionOptions as ɵdl} from './form-entry/question-models/interfaces/multi-select-options';\nexport {SelectOption as ɵdm} from './form-entry/question-models/interfaces/select-option';\nexport {SelectQuestionOptions as ɵdk} from './form-entry/question-models/interfaces/select-question-options';\nexport {TestOrderQuestionOptions as ɵdn} from './form-entry/question-models/interfaces/test-order-question-options';\nexport {TextAreaQuestionOptions as ɵdp} from './form-entry/question-models/interfaces/text-area-question-options';\nexport {TextQuestionOptions as ɵdo} from './form-entry/question-models/interfaces/text-question-options';\nexport {UiSelectQuestionOptions as ɵdq} from './form-entry/question-models/interfaces/ui-select-question-options';\nexport {DebugModeService as ɵdf} from './form-entry/services/debug-mode.service';\nexport {SharedModule as ɵs} from './shared.module';"]}

package/esm2015/public_api.js

@@ -0,0 +1,2 @@
+export * from './lib/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1mb3JtZW50cnkvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9pbmRleCc7XG4iXX0=

package/esm2015/shared.module.js

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { SecurePipe } from './components/file-upload/secure.pipe';
+import { DataSources } from './form-entry/data-sources/data-sources';
+export class SharedModule {
+}
+SharedModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [SecurePipe],
+                imports: [CommonModule],
+                exports: [SecurePipe],
+                providers: [DataSources]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25neC1mb3JtZW50cnkvc3JjL3NoYXJlZC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQ2xFLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQU9yRSxNQUFNLE9BQU8sWUFBWTs7O1lBTnhCLFFBQVEsU0FBQztnQkFDUixZQUFZLEVBQUUsQ0FBQyxVQUFVLENBQUM7Z0JBQzFCLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztnQkFDdkIsT0FBTyxFQUFFLENBQUMsVUFBVSxDQUFDO2dCQUNyQixTQUFTLEVBQUUsQ0FBQyxXQUFXLENBQUM7YUFDekIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IFNlY3VyZVBpcGUgfSBmcm9tICcuL2NvbXBvbmVudHMvZmlsZS11cGxvYWQvc2VjdXJlLnBpcGUnO1xuaW1wb3J0IHsgRGF0YVNvdXJjZXMgfSBmcm9tICcuL2Zvcm0tZW50cnkvZGF0YS1zb3VyY2VzL2RhdGEtc291cmNlcyc7XG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtTZWN1cmVQaXBlXSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtTZWN1cmVQaXBlXSxcbiAgcHJvdmlkZXJzOiBbRGF0YVNvdXJjZXNdXG59KVxuZXhwb3J0IGNsYXNzIFNoYXJlZE1vZHVsZSB7fVxuIl19