@lendi/integrations-transform 1.5.8 → 1.5.9

package/lib/transform-events/transform-applicant.js

@@ -1,106 +1,98 @@
-"use strict";
-exports.__esModule = true;
-exports.generateDependants = exports.generateContact = exports.transformApplicant = exports.booleanMapping = void 0;
-var lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
-var application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
-var lodash_1 = require("lodash");
-var address_tools_1 = require("../utils/address-tools");
-var enum_mappings_1 = require("../types/enum-mappings");
-var public_applicant_1 = require("../types/events/public-applicant");
-var normalise_date_1 = require("../utils/normalise-date");
-var booleanMapping = function (input) {
-    if (input === void 0) { input = false; }
-    return (input === true ? lixi_internal_request_1.YesNoList.Yes : lixi_internal_request_1.YesNoList.No);
-};
-exports.booleanMapping = booleanMapping;
-var applicantMapping = {
-    applicationId: application_paths_1.paths.ApplicationId,
-    citizenship: "".concat(application_paths_1.paths.PersonApplicant, ".@Citizenship"),
-    contact: "".concat(application_paths_1.paths.PersonApplicant, ".Contact"),
+import { CountryCodeList, YesNoList } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
+import { get, omit, set } from 'lodash';
+import { rebuildAddress } from '../utils/address-tools';
+import { countryCodeMapping, maritalStatusMapping, residencyStatusMapping, titleMapping } from '../types/enum-mappings';
+import { ResidencyStatus, Title, } from '../types/events/public-applicant';
+import { normaliseDate } from '../utils/normalise-date';
+export const booleanMapping = (input = false) => (input === true ? YesNoList.Yes : YesNoList.No);
+const applicantMapping = {
+    applicationId: paths.ApplicationId,
+    citizenship: `${paths.PersonApplicant}.@Citizenship`,
+    contact: `${paths.PersonApplicant}.Contact`,
     dependants: 'dependants',
-    dateOfBirth: "".concat(application_paths_1.paths.PersonApplicant, ".@DateOfBirth"),
-    firstName: "".concat(application_paths_1.paths.PersonApplicant, ".PersonName.@FirstName"),
-    id: "".concat(application_paths_1.paths.PersonApplicant, ".@UniqueID"),
-    isFirstHomeBuyer: "".concat(application_paths_1.paths.PersonApplicant, ".@FirstHomeBuyer"),
-    isPrimaryApplicant: "".concat(application_paths_1.paths.PersonApplicant, ".@PrimaryApplicant"),
-    lastName: "".concat(application_paths_1.paths.PersonApplicant, ".PersonName.@Surname"),
-    maritalStatus: "".concat(application_paths_1.paths.PersonApplicant, ".@MaritalStatus"),
-    maritalDetails: "".concat(application_paths_1.paths.PersonApplicant, ".MaritalStatusDetails.@x_Spouse"),
-    middleName: "".concat(application_paths_1.paths.PersonApplicant, ".PersonName.@MiddleNames"),
-    residencyStatus: "".concat(application_paths_1.paths.PersonApplicant, ".@ResidencyStatus"),
-    title: "".concat(application_paths_1.paths.PersonName, ".@NameTitle")
+    dateOfBirth: `${paths.PersonApplicant}.@DateOfBirth`,
+    firstName: `${paths.PersonApplicant}.PersonName.@FirstName`,
+    id: `${paths.PersonApplicant}.@UniqueID`,
+    isFirstHomeBuyer: `${paths.PersonApplicant}.@FirstHomeBuyer`,
+    isPrimaryApplicant: `${paths.PersonApplicant}.@PrimaryApplicant`,
+    lastName: `${paths.PersonApplicant}.PersonName.@Surname`,
+    maritalStatus: `${paths.PersonApplicant}.@MaritalStatus`,
+    maritalDetails: `${paths.PersonApplicant}.MaritalStatusDetails.@x_Spouse`,
+    middleName: `${paths.PersonApplicant}.PersonName.@MiddleNames`,
+    residencyStatus: `${paths.PersonApplicant}.@ResidencyStatus`,
+    title: `${paths.PersonName}.@NameTitle`,
 };
 /**
  * Transforms a partial Applicant event to a partial LIXI application.
  *
  * @param applicant: A partial applicant.
- * @return partialApplication an incomplete application.
+ * @param applicant
+ * @returns partialApplication an incomplete application.
  */
-function transformApplicant(applicant) {
-    var partialApplication = {};
-    var applicantId = applicant.id, applicationId = applicant.applicationId;
-    (0, lodash_1.set)(partialApplication, applicantMapping['isFirstHomeBuyer'], (0, exports.booleanMapping)(applicant.isFirstHomeBuyer));
-    (0, lodash_1.set)(partialApplication, applicantMapping['isPrimaryApplicant'], (0, exports.booleanMapping)(applicant.isPrimaryApplicant));
-    (0, lodash_1.set)(partialApplication, applicantMapping['title'], enum_mappings_1.titleMapping[applicant.title || public_applicant_1.Title.Unknown]);
-    var applicantUpdated = (0, lodash_1.omit)(applicant, ['isFirstHomeBuyer', 'isPrimaryApplicant', 'title']);
-    for (var _i = 0, _a = Object.entries(applicantUpdated); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
+export function transformApplicant(applicant) {
+    const partialApplication = {};
+    const { id: applicantId, applicationId } = applicant;
+    set(partialApplication, applicantMapping['isFirstHomeBuyer'], booleanMapping(applicant.isFirstHomeBuyer));
+    set(partialApplication, applicantMapping['isPrimaryApplicant'], booleanMapping(applicant.isPrimaryApplicant));
+    set(partialApplication, applicantMapping['title'], titleMapping[applicant.title || Title.Unknown]);
+    const applicantUpdated = omit(applicant, ['isFirstHomeBuyer', 'isPrimaryApplicant', 'title']);
+    for (const [key, value] of Object.entries(applicantUpdated)) {
         if (applicantMapping[key]) {
             switch (key) {
                 case 'dateOfBirth':
-                    (0, lodash_1.set)(partialApplication, applicantMapping[key], (0, normalise_date_1.normaliseDate)(value));
+                    set(partialApplication, applicantMapping[key], normaliseDate(value));
                     break;
                 case 'maritalStatus':
-                    (0, lodash_1.set)(partialApplication, applicantMapping[key], enum_mappings_1.maritalStatusMapping[value]);
+                    set(partialApplication, applicantMapping[key], maritalStatusMapping[value]);
                     break;
                 case 'citizenship':
-                    (0, lodash_1.set)(partialApplication, applicantMapping[key], enum_mappings_1.countryCodeMapping[value]);
+                    set(partialApplication, applicantMapping[key], countryCodeMapping[value]);
                     break;
                 case 'residencyStatus':
-                    (0, lodash_1.set)(partialApplication, applicantMapping[key], enum_mappings_1.residencyStatusMapping[value]);
+                    set(partialApplication, applicantMapping[key], residencyStatusMapping[value]);
                     // Certain bank integrations require the ability to differentiate between permanentResident and Citizen
                     // As lixi does not have a citizen enum for residencyStatus citizen is mapped to permanentResident
                     // Adding a @Citizenship attribute to person applicant gives us the ability to determine citizenship status
                     // If citizen this field will be always added and value will be AU.
                     // @tsilva 21/11/19
-                    if (value === public_applicant_1.ResidencyStatus.AustralianCitizen) {
-                        (0, lodash_1.set)(partialApplication, applicantMapping.citizenship, lixi_internal_request_1.CountryCodeList.Au);
+                    if (value === ResidencyStatus.AustralianCitizen) {
+                        set(partialApplication, applicantMapping.citizenship, CountryCodeList.Au);
                     }
                     break;
                 case 'maritalDetails':
-                    var id = (0, lodash_1.get)(value, 'applicantId');
+                    const id = get(value, 'applicantId');
                     if (id)
-                        (0, lodash_1.set)(partialApplication, applicantMapping[key], id);
+                        set(partialApplication, applicantMapping[key], id);
                     break;
                 case 'contact':
-                    var _c = generateContact(value, applicantId), lixiContact = _c.lixiContact, lixiAddresses = _c.lixiAddresses;
-                    (0, lodash_1.set)(partialApplication, applicantMapping[key], lixiContact);
+                    const { lixiContact, lixiAddresses } = generateContact(value, applicantId);
+                    set(partialApplication, applicantMapping[key], lixiContact);
                     if (lixiAddresses.length > 0) {
-                        (0, lodash_1.set)(partialApplication, application_paths_1.paths.Addresses, lixiAddresses);
+                        set(partialApplication, paths.Addresses, lixiAddresses);
                     }
                     break;
                 case 'dependants':
-                    var dependants = generateDependants(value, applicantId);
-                    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.Household, ".@UniqueID"), "".concat(applicationId, "-household"));
-                    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.Household, ".Dependant"), dependants);
+                    const dependants = generateDependants(value, applicantId);
+                    set(partialApplication, `${paths.Household}.@UniqueID`, `${applicationId}-household`);
+                    set(partialApplication, `${paths.Household}.Dependant`, dependants);
                     break;
                 default:
-                    (0, lodash_1.set)(partialApplication, applicantMapping[key], value);
+                    set(partialApplication, applicantMapping[key], value);
                     break;
             }
         }
     }
     return partialApplication;
 }
-exports.transformApplicant = transformApplicant;
-var contactMapping = {
+const contactMapping = {
     emailAddress: 'EmailAddress.0.@Email',
     mobileNumber: 'Mobile.@Number',
     currentAddress: 'CurrentAddress',
     previousAddresses: 'PreviousAddress',
     priorAddress: 'PriorAddress',
     mailingAddress: 'CurrentAddress.@x_MailingAddress',
-    postSettlementAddress: 'PostSettlementAddress'
+    postSettlementAddress: 'PostSettlementAddress',
 };
 /**
  * Generates a LIXI contact from given contact.
@@ -108,79 +100,74 @@ var contactMapping = {
  * @param contact
  * @param id
  */
-function generateContact(contact, id) {
-    var lixiContact = {};
-    var lixiAddresses = [];
-    for (var _i = 0, _a = Object.entries(contact); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
+export function generateContact(contact, id) {
+    const lixiContact = {};
+    const lixiAddresses = [];
+    for (const [key, value] of Object.entries(contact)) {
         if (contactMapping[key]) {
             switch (key) {
                 case 'currentAddress':
                     {
-                        var addressId = "".concat(id, "-current");
-                        var _c = (0, address_tools_1.rebuildAddress)(value, addressId), lixiAddress = _c.lixiAddress, lixiContactAddress = _c.lixiContactAddress;
+                        const addressId = `${id}-current`;
+                        const { lixiAddress, lixiContactAddress } = rebuildAddress(value, addressId);
                         lixiAddresses.push(lixiAddress);
-                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
+                        set(lixiContact, contactMapping[key], lixiContactAddress);
                     }
                     break;
                 case 'postSettlementAddress':
                     {
-                        var addressId = "".concat(id, "-postSettlement");
-                        var _d = (0, address_tools_1.rebuildAddress)({ residentialAddress: value }, addressId), lixiAddress = _d.lixiAddress, lixiContactAddress = _d.lixiContactAddress;
+                        const addressId = `${id}-postSettlement`;
+                        const { lixiAddress, lixiContactAddress } = rebuildAddress({ residentialAddress: value }, addressId);
                         lixiAddresses.push(lixiAddress);
-                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
+                        set(lixiContact, contactMapping[key], lixiContactAddress);
                     }
                     break;
                 case 'mailingAddress':
                     {
-                        var addressId = "".concat(id, "-mailing");
-                        var lixiAddress = (0, address_tools_1.rebuildAddress)({ residentialAddress: value }, addressId).lixiAddress;
+                        const addressId = `${id}-mailing`;
+                        const { lixiAddress } = rebuildAddress({ residentialAddress: value }, addressId);
                         lixiAddresses.push(lixiAddress);
-                        (0, lodash_1.set)(lixiContact, contactMapping[key], addressId);
+                        set(lixiContact, contactMapping[key], addressId);
                     }
                     break;
                 case 'previousAddresses':
                     {
-                        var addressId = "".concat(id, "-previous");
-                        var previousAddresses = value.sort(function (lhs, rhs) {
-                            return lhs.endDate.localeCompare(rhs.endDate);
-                        });
-                        var previousAddress = previousAddresses.pop();
-                        var _e = (0, address_tools_1.rebuildAddress)(previousAddress, addressId), lixiAddress = _e.lixiAddress, lixiContactAddress = _e.lixiContactAddress;
+                        const addressId = `${id}-previous`;
+                        const previousAddresses = value.sort((lhs, rhs) => lhs.endDate.localeCompare(rhs.endDate));
+                        const previousAddress = previousAddresses.pop();
+                        const { lixiAddress, lixiContactAddress } = rebuildAddress(previousAddress, addressId);
                         lixiAddresses.push(lixiAddress);
-                        (0, lodash_1.set)(lixiContact, contactMapping[key], lixiContactAddress);
+                        set(lixiContact, contactMapping[key], lixiContactAddress);
                         // PriorAddresses
-                        previousAddresses.forEach(function (address, index) {
-                            var _a = (0, address_tools_1.rebuildAddress)(address, "".concat(id, "-prior-").concat(index)), lixiAddress = _a.lixiAddress, lixiContactAddress = _a.lixiContactAddress;
+                        previousAddresses.forEach((address, index) => {
+                            const { lixiAddress, lixiContactAddress } = rebuildAddress(address, `${id}-prior-${index}`);
                             lixiAddresses.push(lixiAddress);
-                            (0, lodash_1.set)(lixiContact, "".concat(contactMapping['priorAddress'], ".").concat(index), lixiContactAddress);
+                            set(lixiContact, `${contactMapping['priorAddress']}.${index}`, lixiContactAddress);
                         });
                     }
                     break;
                 default:
-                    (0, lodash_1.set)(lixiContact, contactMapping[key], value);
+                    set(lixiContact, contactMapping[key], value);
                     break;
             }
         }
     }
-    return { lixiContact: lixiContact, lixiAddresses: lixiAddresses };
+    return { lixiContact, lixiAddresses };
 }
-exports.generateContact = generateContact;
 /**
  * Generate dependants
  *
  * @param dependants
  * @param id
  */
-function generateDependants(dependants, id) {
-    return dependants.map(function (dependant) { return ({
+export function generateDependants(dependants, id) {
+    return dependants.map((dependant) => ({
         '@Age': dependant.age,
         '@UniqueID': dependant.id,
         FinancialProvider: [
             {
-                '@x_Party': id
+                '@x_Party': id,
             },
-        ]
-    }); });
+        ],
+    }));
 }
-exports.generateDependants = generateDependants;

package/lib/transform-events/transform-application-workflow.d.ts

@@ -3,7 +3,6 @@ import { PayloadClass as ApplicationWorkflowEventPayload } from '../types/events
  * Generates a partial application from an ApplicationWorkflow event
  *
  * @param applicationWorkflowEventPayload ApplicationWorkflow event payload
- *
  * @returns A partial application
  */
 export declare function transformApplicationWorkflow(applicationWorkflowEventPayload: ApplicationWorkflowEventPayload): {};

package/lib/transform-events/transform-application-workflow.js

@@ -1,24 +1,19 @@
-"use strict";
-exports.__esModule = true;
-exports.transformApplicationWorkflow = void 0;
-var application_paths_1 = require("@lendi/integrations-protocol/lib/utils/application-paths");
-var lodash_1 = require("lodash");
+import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
+import { set } from 'lodash';
 /**
  * Generates a partial application from an ApplicationWorkflow event
  *
  * @param applicationWorkflowEventPayload ApplicationWorkflow event payload
- *
  * @returns A partial application
  */
-function transformApplicationWorkflow(applicationWorkflowEventPayload) {
-    var stage = applicationWorkflowEventPayload.stage, applicationStage = applicationWorkflowEventPayload.applicationStage, applicationId = applicationWorkflowEventPayload.applicationId, partialApplication = {};
-    (0, lodash_1.set)(partialApplication, application_paths_1.paths.ApplicationId, applicationId);
+export function transformApplicationWorkflow(applicationWorkflowEventPayload) {
+    const { stage, applicationStage, applicationId } = applicationWorkflowEventPayload, partialApplication = {};
+    set(partialApplication, paths.ApplicationId, applicationId);
     // The stage being defaulted to Unknown caters for LGSF application workflow events having stage as an optional attribute in the future
-    var instructionDetails = {
-        '@UniqueID': "".concat(applicationId, "-stage"),
-        '@Details': applicationStage || stage || 'Unknown'
+    const instructionDetails = {
+        '@UniqueID': `${applicationId}-stage`,
+        '@Details': applicationStage || stage || 'Unknown',
     };
-    (0, lodash_1.set)(partialApplication, application_paths_1.paths.Instructions, instructionDetails);
+    set(partialApplication, paths.Instructions, instructionDetails);
     return partialApplication;
 }
-exports.transformApplicationWorkflow = transformApplicationWorkflow;

package/lib/transform-events/transform-application.d.ts

@@ -8,7 +8,9 @@ interface transformApplicationOptions {
  *
  * @param opportunity: Partial opportunity event.
  * @param uniqueIdSuffix: Suffix for uniquerId
- * @return  partialApplication: A partial internal request.
+ * @param opportunity
+ * @param options
+ * @returns  partialApplication: A partial internal request.
  */
 export declare function transformApplication(opportunity: ApplicationPayload, options?: transformApplicationOptions): {};
 export {};

package/lib/transform-events/transform-application.js

@@ -1,61 +1,56 @@
-"use strict";
-exports.__esModule = true;
-exports.transformApplication = void 0;
-var lixi_internal_request_1 = require("@lendi/integrations-credit-protocol/types/lixi-internal-request");
-var application_paths_1 = require("@lendi/integrations-credit-protocol/utils/application-paths");
-var application_paths_2 = require("@lendi/integrations-protocol/lib/utils/application-paths");
-var lodash_1 = require("lodash");
-var enum_mappings_1 = require("../types/enum-mappings/");
-var transform_applicant_1 = require("./transform-applicant");
+import { EventNameApplicationInstructionsList } from '@lendi/integrations-credit-protocol/types/lixi-internal-request';
+import { paths as creditProtocolPaths } from '@lendi/integrations-credit-protocol/utils/application-paths';
+import { paths } from '@lendi/integrations-protocol/lib/utils/application-paths';
+import { set } from 'lodash';
+import { preferredRepaymentMapping, transactionTypeMapping } from '../types/enum-mappings/';
+import { booleanMapping } from './transform-applicant';
 /**
  * Transforms a partial opportunity event to a partial internal request.
  *
  * @param opportunity: Partial opportunity event.
  * @param uniqueIdSuffix: Suffix for uniquerId
- * @return  partialApplication: A partial internal request.
+ * @param opportunity
+ * @param options
+ * @returns  partialApplication: A partial internal request.
  */
-function transformApplication(opportunity, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.uniqueIdSuffix, uniqueIdSuffix = _a === void 0 ? 'loanDetails' : _a, _b = options.enableRateLock, enableRateLock = _b === void 0 ? false : _b;
-    var partialApplication = {};
-    var opportunityMapping = {
-        brand: application_paths_2.paths.BusinessName,
-        id: application_paths_2.paths.ApplicationId,
-        paymentType: "".concat(application_paths_2.paths.LoanTerm, ".@PaymentType"),
+export function transformApplication(opportunity, options = {}) {
+    const { uniqueIdSuffix = 'loanDetails', enableRateLock = false } = options;
+    const partialApplication = {};
+    const opportunityMapping = {
+        brand: paths.BusinessName,
+        id: paths.ApplicationId,
+        paymentType: `${paths.LoanTerm}.@PaymentType`,
         preliminary: 'preliminary',
-        primaryPurpose: application_paths_2.paths.PurposeOfApplication,
-        brokerPrimaryPurpose: 'Package.Content.NeedsAnalysis.PurposeOfApplication[0].@Description'
+        primaryPurpose: paths.PurposeOfApplication,
+        brokerPrimaryPurpose: 'Package.Content.NeedsAnalysis.PurposeOfApplication[0].@Description',
     };
-    (0, lodash_1.set)(partialApplication, "".concat(application_paths_2.paths.LoanDetail, ".@UniqueID"), "".concat(opportunity.id, "-").concat(uniqueIdSuffix));
-    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.Instructions, ".@UniqueID"), "".concat(opportunity.id, "-stage"));
-    (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.Instructions, ".@Name"), lixi_internal_request_1.EventNameApplicationInstructionsList.ApplicationReceived);
+    set(partialApplication, `${paths.LoanDetail}.@UniqueID`, `${opportunity.id}-${uniqueIdSuffix}`);
+    set(partialApplication, `${creditProtocolPaths.Instructions}.@UniqueID`, `${opportunity.id}-stage`);
+    set(partialApplication, `${creditProtocolPaths.Instructions}.@Name`, EventNameApplicationInstructionsList.ApplicationReceived);
     if (enableRateLock) {
-        var _c = opportunity.hasOptedInRateLock, hasOptedInRateLock = _c === void 0 ? false : _c;
-        (0, lodash_1.set)(partialApplication, "".concat(application_paths_1.paths.FeaturesSelected, ".@RateLock"), (0, transform_applicant_1.booleanMapping)(hasOptedInRateLock));
+        const { hasOptedInRateLock = false } = opportunity;
+        set(partialApplication, `${creditProtocolPaths.FeaturesSelected}.@RateLock`, booleanMapping(hasOptedInRateLock));
     }
-    for (var _i = 0, _d = Object.entries(opportunity); _i < _d.length; _i++) {
-        var _e = _d[_i], opportunityKey = _e[0], opportunityValue = _e[1];
+    for (const [opportunityKey, opportunityValue] of Object.entries(opportunity)) {
         if (opportunityMapping[opportunityKey]) {
             if (opportunityKey === 'preliminary') {
-                for (var _f = 0, _g = Object.entries(opportunityValue); _f < _g.length; _f++) {
-                    var _h = _g[_f], key = _h[0], value = _h[1];
+                for (const [key, value] of Object.entries(opportunityValue)) {
                     if (opportunityMapping[key]) {
                         switch (key) {
                             case 'paymentType':
-                                (0, lodash_1.set)(partialApplication, opportunityMapping[key], enum_mappings_1.preferredRepaymentMapping[value]);
+                                set(partialApplication, opportunityMapping[key], preferredRepaymentMapping[value]);
                                 break;
                             case 'primaryPurpose':
-                                (0, lodash_1.set)(partialApplication, opportunityMapping[key], enum_mappings_1.transactionTypeMapping[value]);
+                                set(partialApplication, opportunityMapping[key], transactionTypeMapping[value]);
                                 break;
                         }
                     }
                 }
             }
             else {
-                (0, lodash_1.set)(partialApplication, opportunityMapping[opportunityKey], opportunityValue);
+                set(partialApplication, opportunityMapping[opportunityKey], opportunityValue);
             }
         }
     }
     return partialApplication;
 }
-exports.transformApplication = transformApplication;

package/lib/transform-events/transform-asset-address.d.ts

@@ -1,5 +1,9 @@
 import { AddressType, Standard } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
 import { Address, AddressStandard } from '../types/events/public-asset';
+/**
+ *
+ * @param address
+ */
 export declare function getAddressMapping(address: Address): Record<string, string>;
 export declare const standardMapping: Record<string, string>;
 /**
@@ -8,12 +12,14 @@ export declare const standardMapping: Record<string, string>;
  * @param address: An address object.
  * @param id: address event id.
  * @param toBeUsedAsSecurity
- * @return A transformed address object.
+ * @param address
+ * @param id
+ * @returns A transformed address object.
  */
 export declare function transformAddress(address: Address, id: string): Partial<AddressType>;
 /**
  * @description Generates an address standard.
  * @param {AddressStandard} addressStandard An address standard object.
- * @return {Partial<Standard>} A transformed standard object.
+ * @returns {Partial<Standard>} A transformed standard object.
  */
 export declare function transformStandard(addressStandard: AddressStandard): Partial<Standard>;

package/lib/transform-events/transform-asset-address.js

@@ -1,27 +1,27 @@
-"use strict";
-exports.__esModule = true;
-exports.transformStandard = exports.transformAddress = exports.standardMapping = exports.getAddressMapping = void 0;
-var lixi_internal_request_1 = require("@lendi/integrations-protocol/lib/types/lixi-internal-request");
-var lodash_1 = require("lodash");
-var enum_mappings_1 = require("../types/enum-mappings");
-var address_tools_1 = require("../utils/address-tools");
-function getAddressMapping(address) {
+import { CountryCodeList } from '@lendi/integrations-protocol/lib/types/lixi-internal-request';
+import { set } from 'lodash';
+import { countryCodeMapping, postcodeMapping } from '../types/enum-mappings';
+import { extractCountryFromFormatted, isOverseasAddress } from '../utils/address-tools';
+/**
+ *
+ * @param address
+ */
+export function getAddressMapping(address) {
     return {
         city: '@Suburb',
         country: '@Country',
-        postcode: (0, address_tools_1.isOverseasAddress)(address) ? '@OverseasPostCode' : '@AustralianPostCode',
-        state: (0, address_tools_1.isOverseasAddress)(address) ? '@OverseasState' : '@AustralianState',
+        postcode: isOverseasAddress(address) ? '@OverseasPostCode' : '@AustralianPostCode',
+        state: isOverseasAddress(address) ? '@OverseasState' : '@AustralianState',
         standard: 'Standard',
-        formatted: '@Country'
+        formatted: '@Country',
     };
 }
-exports.getAddressMapping = getAddressMapping;
-exports.standardMapping = {
+export const standardMapping = {
     streetName: '@StreetName',
     streetType: '@StreetType',
     streetNumber: '@StreetNumber',
     level: '@Level',
-    unit: '@Unit'
+    unit: '@Unit',
 };
 /**
  * Generates an address for an asset.
@@ -29,55 +29,53 @@ exports.standardMapping = {
  * @param address: An address object.
  * @param id: address event id.
  * @param toBeUsedAsSecurity
- * @return A transformed address object.
+ * @param address
+ * @param id
+ * @returns A transformed address object.
  */
-function transformAddress(address, id) {
-    var transformedAddress = {
-        '@UniqueID': id
+export function transformAddress(address, id) {
+    const transformedAddress = {
+        '@UniqueID': id,
     };
-    var addressMapping = getAddressMapping(address);
+    const addressMapping = getAddressMapping(address);
     // for an Australian address: if no postcode is provided, infer one from the state:
-    if (!(0, address_tools_1.isOverseasAddress)(address) && address.state && !address.postcode) {
-        address.postcode = enum_mappings_1.postcodeMapping[address.state];
+    if (!isOverseasAddress(address) && address.state && !address.postcode) {
+        address.postcode = postcodeMapping[address.state];
     }
-    for (var _i = 0, _a = Object.entries(address); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
+    for (const [key, value] of Object.entries(address)) {
         if (addressMapping[key]) {
             switch (key) {
                 case 'standard':
-                    (0, lodash_1.set)(transformedAddress, addressMapping[key], transformStandard(value));
+                    set(transformedAddress, addressMapping[key], transformStandard(value));
                     break;
                 case 'country':
-                    (0, lodash_1.set)(transformedAddress, addressMapping[key], (0, address_tools_1.isOverseasAddress)(address) ? enum_mappings_1.countryCodeMapping[value] : lixi_internal_request_1.CountryCodeList.Au);
+                    set(transformedAddress, addressMapping[key], isOverseasAddress(address) ? countryCodeMapping[value] : CountryCodeList.Au);
                     break;
                 case 'formatted':
                     if (!address.country) {
-                        var country = (0, address_tools_1.extractCountryFromFormatted)(value);
-                        (0, lodash_1.set)(transformedAddress, addressMapping[key], enum_mappings_1.countryCodeMapping[country]);
+                        const country = extractCountryFromFormatted(value);
+                        set(transformedAddress, addressMapping[key], countryCodeMapping[country]);
                     }
                     break;
                 default:
-                    (0, lodash_1.set)(transformedAddress, addressMapping[key], value);
+                    set(transformedAddress, addressMapping[key], value);
                     break;
             }
         }
     }
     return transformedAddress;
 }
-exports.transformAddress = transformAddress;
 /**
  * @description Generates an address standard.
  * @param {AddressStandard} addressStandard An address standard object.
- * @return {Partial<Standard>} A transformed standard object.
+ * @returns {Partial<Standard>} A transformed standard object.
  */
-function transformStandard(addressStandard) {
-    var transformedStandard = {};
-    for (var _i = 0, _a = Object.entries(addressStandard); _i < _a.length; _i++) {
-        var _b = _a[_i], key = _b[0], value = _b[1];
-        if (exports.standardMapping[key]) {
-            (0, lodash_1.set)(transformedStandard, exports.standardMapping[key], value);
+export function transformStandard(addressStandard) {
+    const transformedStandard = {};
+    for (const [key, value] of Object.entries(addressStandard)) {
+        if (standardMapping[key]) {
+            set(transformedStandard, standardMapping[key], value);
         }
     }
     return transformedStandard;
 }
-exports.transformStandard = transformStandard;

package/lib/transform-events/transform-asset.d.ts

@@ -12,7 +12,7 @@ export declare const residentialTypeList: string[];
  * Generates a partial internal request from a partial public asset event.
  *
  * @param {Payload} asset - A partial public asset.
- * @return {PartialApplication} A partial InternalRequest.
+ * @returns {PartialApplication} A partial InternalRequest.
  */
 export declare function transformAsset({ asset, applicationId, id }: Payload): PartialApplication;
 /**
@@ -33,20 +33,26 @@ export declare function getAssetMapping(asset: Asset): Record<string, string>;
  * @param percentOwned: owners of the property
  * @param assetId: Asset id
  * @param propertyExpenses: propertyExpenses items
+ * @param percentOwned
+ * @param assetId
+ * @param propertyExpenses
  */
 export declare function generateLivingExpenses(percentOwned: PercentOwned, assetId: string, propertyExpenses: PropertyExpense[]): LivingExpense[];
 /**
  * Creates PropertyExpense array on RealEstateAsset from the same array on the event.
+ *
  * @param propertyExpenses
  */
 export declare function generatePropertyExpenses(propertyExpenses: PropertyExpense[]): LIXIPropertyExpense[];
 /**
  * Determines the occupancy based on the list of property expense types available.
+ *
  * @param propertyExpenses
  */
 export declare function determineOccupancy(propertyExpenses: PropertyExpense[]): OccupancyList;
 /**
  * Calculates the correct amount and frequency.
+ *
  * @param expense
  */
 export declare function normalizeAmounts(expense: PropertyExpense): PropertyExpense;