@decafhub/decaf-client-extras 0.0.1

package/reports/valuation/-remote-valuation-report-shared.d.ts

@@ -0,0 +1,233 @@
+import { CustomError, Decimal, Either, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { ArtifactId, ArtifactTypeId, CurrencyCode, DateType } from '../../commons';
+import { BaseValuationReport, BaseValuationReportHolding, ValuationReportAccount, ValuationReportAccounts, ValuationReportAccrual, ValuationReportArtifact, ValuationReportFigureOrgRef, ValuationReportHolding } from './-valuation-report-shared';
+export interface RemoteBaseValuationReport {
+    reported: SDateTime;
+    asof: SDate;
+    type: DateType;
+    ccy: CurrencyCode;
+    accounts: ValuationReportAccounts;
+    holdings: RemoteValuationReportHolding[];
+    accruals: RemoteValuationReportAccrual[];
+    investment?: number;
+    valuation_net?: number;
+    valuation_abs?: number;
+    accrued?: number;
+    liabilities?: number;
+    gav?: number;
+    nav?: number;
+    aum?: number;
+    pnl?: number;
+    pnl_to_investment?: number;
+    fxrates: RemoteValuationReportFxRate[];
+}
+export interface RemoteValuationReportFxRate {
+    ccy1: CurrencyCode;
+    ccy2: CurrencyCode;
+    value: number;
+    asof: SDate;
+}
+/**
+ * Valuation holding.
+ */
+export interface RemoteValuationReportHolding {
+    artifact: RemoteValuationReportArtifact;
+    tags: {
+        classification: {
+            name: string;
+            order?: string | number;
+        }[];
+    };
+    quantity: number;
+    accounts: ValuationReportAccount[];
+    investment: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        txncosts: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            org?: number;
+            ref?: number;
+        };
+    };
+    valuation: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+        exposure: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+    };
+    children: RemoteValuationReportChildHolding[];
+    change?: number;
+    pnl?: number;
+    pnl_to_investment?: number;
+    opendate: SDate;
+    lastdate: SDate;
+}
+/**
+ * Valuation child holding.
+ */
+export interface RemoteValuationReportChildHolding {
+    artifact: RemoteValuationReportArtifact;
+    tags: {};
+    quantity: number;
+    accounts: ValuationReportAccount[];
+    investment: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        txncosts: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            org?: number;
+            ref?: number;
+        };
+    };
+    valuation: {
+        px: {
+            org?: number;
+            ref?: number;
+        };
+        accrued: {
+            org?: number;
+            ref?: number;
+        };
+        value: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+        exposure: {
+            net: {
+                org?: number;
+                ref?: number;
+            };
+            abs: {
+                org?: number;
+                ref?: number;
+            };
+        };
+    };
+    change?: number;
+    pnl?: number;
+    pnl_to_investment?: number;
+    opendate: SDate;
+    lastdate: SDate;
+}
+/**
+ * Valuation artifact.
+ */
+export interface RemoteValuationReportArtifact {
+    id: ArtifactId;
+    guid: string;
+    type: {
+        id: ArtifactTypeId;
+        name: string;
+        order: number;
+    };
+    stype?: string;
+    symbol: string;
+    name?: string;
+    ccy?: CurrencyCode;
+    quantity: number;
+    country?: string;
+    issuer?: string;
+    sector?: string;
+    mic?: string;
+    ticker?: string;
+    isin?: string;
+    figi?: string;
+    expiry?: SDate;
+    underlying_id?: ArtifactId;
+}
+/**
+ * Valuation accrual.
+ */
+export interface RemoteValuationReportAccrual {
+    name: string;
+    value: number;
+    accounts: RemoteValuationReportAccrualByAccount[];
+}
+/**
+ * Valuation accrual by account.
+ */
+export interface RemoteValuationReportAccrualByAccount {
+    account: ValuationReportAccount;
+    value: number;
+    accruals: RemoteValuationReportAccrualByCurrency[];
+}
+/**
+ * Valuation accrual by account by currency.
+ */
+export interface RemoteValuationReportAccrualByCurrency {
+    artifact: RemoteValuationReportArtifact;
+    ccy: CurrencyCode;
+    value: {
+        org?: number;
+        ref?: number;
+    };
+}
+export declare function toArtifact(x: RemoteValuationReportArtifact): ValuationReportArtifact;
+export declare function toAccrual(x: RemoteValuationReportAccrual): ValuationReportAccrual;
+export declare function toOrgRef(x: {
+    org?: number;
+    ref?: number;
+}): ValuationReportFigureOrgRef;
+export declare function toMaybeOrgRef(x?: {
+    org?: number;
+    ref?: number;
+}): Maybe<ValuationReportFigureOrgRef>;
+export declare function toBaseHolding(nav: Decimal, x: RemoteValuationReportHolding | RemoteValuationReportChildHolding): BaseValuationReportHolding;
+export declare function toHolding(nav: Decimal, x: RemoteValuationReportHolding): ValuationReportHolding;
+/**
+ * Attempts to re-compile the raw, remote base valuation report and
+ * return it.
+ *
+ * @param x Raw, remote base valuation report.
+ * @returns Either of an error message or the re-compiled base valuation
+ * report.
+ */
+export declare function recompileBaseValuationReport(x: RemoteBaseValuationReport): Either<CustomError, BaseValuationReport>;

package/reports/valuation/-remote-valuation-report-shared.js

@@ -0,0 +1,145 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recompileBaseValuationReport = exports.toHolding = exports.toBaseHolding = exports.toMaybeOrgRef = exports.toOrgRef = exports.toAccrual = exports.toArtifact = void 0;
+var prelude_1 = require("@telostat/prelude");
+function toArtifact(x) {
+    return {
+        id: x.id,
+        guid: x.guid,
+        type: x.type,
+        stype: (0, prelude_1.sanitizedNonEmptyText)(x.stype),
+        symbol: x.symbol,
+        name: (0, prelude_1.sanitizedNonEmptyText)(x.name),
+        ccy: prelude_1.Maybe.fromNullable(x.ccy),
+        quantity: (0, prelude_1.asDecimal)(x.quantity),
+        country: (0, prelude_1.sanitizedNonEmptyText)(x.country),
+        issuer: (0, prelude_1.sanitizedNonEmptyText)(x.issuer),
+        sector: (0, prelude_1.sanitizedNonEmptyText)(x.sector),
+        mic: (0, prelude_1.sanitizedNonEmptyText)(x.mic),
+        ticker: (0, prelude_1.sanitizedNonEmptyText)(x.ticker),
+        isin: (0, prelude_1.sanitizedNonEmptyText)(x.isin),
+        figi: (0, prelude_1.sanitizedNonEmptyText)(x.figi),
+        expiry: prelude_1.Maybe.fromNullable(x.expiry),
+        underlyingId: prelude_1.Maybe.fromNullable(x.underlying_id),
+    };
+}
+exports.toArtifact = toArtifact;
+function toAccrual(x) {
+    return {
+        name: x.name,
+        value: (0, prelude_1.asDecimal)(x.value),
+        accounts: x.accounts.map(function (y) { return ({
+            account: y.account,
+            value: (0, prelude_1.asDecimal)(y.value),
+            accruals: y.accruals.map(function (z) { return ({
+                artifact: toArtifact(z.artifact),
+                ccy: z.ccy,
+                value: { org: (0, prelude_1.asDecimal)(z.value.org || 0), ref: (0, prelude_1.asDecimal)(z.value.ref || 0) },
+            }); }),
+        }); }),
+    };
+}
+exports.toAccrual = toAccrual;
+function toOrgRef(x) {
+    return {
+        org: (0, prelude_1.maybeDecimal)(x.org).orDefault(prelude_1.zero),
+        ref: (0, prelude_1.maybeDecimal)(x.ref).orDefault(prelude_1.zero),
+    };
+}
+exports.toOrgRef = toOrgRef;
+function toMaybeOrgRef(x) {
+    return prelude_1.Maybe.fromNullable(x).chain(function (_a) {
+        var org = _a.org, ref = _a.ref;
+        return (0, prelude_1.maybeDecimal)(org).chain(function (o) { return (0, prelude_1.maybeDecimal)(ref).chain(function (r) { return (0, prelude_1.Just)({ org: o, ref: r }); }); });
+    });
+}
+exports.toMaybeOrgRef = toMaybeOrgRef;
+function toBaseHolding(nav, x) {
+    return {
+        artifact: toArtifact(x.artifact),
+        quantity: (0, prelude_1.asDecimal)(x.quantity),
+        investment: {
+            px: toOrgRef(x.investment.px),
+            txncosts: toMaybeOrgRef(x.investment.txncosts),
+            accrued: toMaybeOrgRef(x.investment.accrued),
+            value: toOrgRef(x.investment.value),
+        },
+        valuation: {
+            px: toOrgRef(x.valuation.px),
+            accrued: toMaybeOrgRef(x.valuation.accrued),
+            value: {
+                net: toOrgRef(x.valuation.value.net),
+                abs: toOrgRef(x.valuation.value.abs),
+            },
+            exposure: {
+                net: toOrgRef(x.valuation.exposure.net),
+                abs: toOrgRef(x.valuation.exposure.abs),
+            },
+        },
+        valuePercentage: (0, prelude_1.safeDiv)((0, prelude_1.maybeDecimal)(x.valuation.value.net.ref).orDefault(prelude_1.zero), nav),
+        netExposurePercentage: (0, prelude_1.safeDiv)((0, prelude_1.maybeDecimal)(x.valuation.exposure.net.ref).orDefault(prelude_1.zero), nav),
+        absExposurePercentage: (0, prelude_1.safeDiv)((0, prelude_1.maybeDecimal)(x.valuation.exposure.abs.ref).orDefault(prelude_1.zero), nav),
+        change: (0, prelude_1.maybeDecimal)(x.change),
+        pnl: (0, prelude_1.maybeDecimal)(x.pnl).orDefault(prelude_1.zero),
+        pnlToInvestment: (0, prelude_1.maybeDecimal)(x.pnl_to_investment),
+        opendate: x.opendate,
+        lastdate: x.lastdate,
+    };
+}
+exports.toBaseHolding = toBaseHolding;
+function toHolding(nav, x) {
+    return __assign(__assign({}, toBaseHolding(nav, x)), { classification: x.tags.classification.map(function (n) { return (__assign(__assign({}, n), { order: n.order || '' })); }), accounts: x.accounts, children: prelude_1.Maybe.fromNullable(x.children)
+            .filter(function (mc) { return mc.length !== 0; })
+            .map(function (mc) {
+            return mc.map(function (c) { return (__assign(__assign({}, toBaseHolding(nav, c)), { account: c.accounts[0] })); });
+        }) });
+}
+exports.toHolding = toHolding;
+/**
+ * Attempts to re-compile the raw, remote base valuation report and
+ * return it.
+ *
+ * @param x Raw, remote base valuation report.
+ * @returns Either of an error message or the re-compiled base valuation
+ * report.
+ */
+function recompileBaseValuationReport(x) {
+    var nav = (0, prelude_1.maybeDecimal)(x.nav).orDefault(prelude_1.zero);
+    var report = {
+        asof: x.reported,
+        date: x.asof,
+        dateType: x.type,
+        currency: x.ccy,
+        accounts: x.accounts,
+        holdings: x.holdings.map(function (rh) { return toHolding(nav, rh); }),
+        accruals: x.accruals.map(toAccrual),
+        fxRates: x.fxrates.map(function (r) { return ({ ccy1: r.ccy1, ccy2: r.ccy2, value: (0, prelude_1.asDecimal)(r.value), asof: r.asof }); }),
+        figures: {
+            investment: (0, prelude_1.maybeDecimal)(x.investment).orDefault(prelude_1.zero),
+            valuation: {
+                net: (0, prelude_1.maybeDecimal)(x.valuation_net).orDefault(prelude_1.zero),
+                abs: (0, prelude_1.maybeDecimal)(x.valuation_abs).orDefault(prelude_1.zero),
+            },
+            accrued: (0, prelude_1.maybeDecimal)(x.accrued).orDefault(prelude_1.zero),
+            liabilities: (0, prelude_1.maybeDecimal)(x.liabilities).orDefault(prelude_1.zero),
+            gav: (0, prelude_1.maybeDecimal)(x.gav).orDefault(prelude_1.zero),
+            nav: nav,
+            aum: (0, prelude_1.maybeDecimal)(x.aum).orDefault(prelude_1.zero),
+            pnl: (0, prelude_1.maybeDecimal)(x.pnl).orDefault(prelude_1.zero),
+            pnlToInvestment: (0, prelude_1.maybeDecimal)(x.pnl_to_investment),
+        },
+    };
+    return (0, prelude_1.Right)(report);
+}
+exports.recompileBaseValuationReport = recompileBaseValuationReport;

package/reports/valuation/-valuation-report-consolidated.d.ts

@@ -0,0 +1,35 @@
+import { BaseValuationReport } from './-valuation-report-shared';
+/**
+ * Type definition for consolidated valuation report.
+ */
+export interface ConsolidatedValuationReport extends BaseValuationReport {
+    /**
+     * Type of containers consolidated.
+     */
+    containerType: ConsolidatedValuationReportContainerType;
+    /**
+     * Containers consolidated.
+     */
+    containers: ConsolidatedValuationReportContainer[];
+}
+/**
+ * Type definition for container types to be consolidated.
+ */
+export declare type ConsolidatedValuationReportContainerType = 'account' | 'portfolio' | 'team' | 'custodian' | 'portfolio-group';
+/**
+ * Type definition for valuation report containers.
+ */
+export interface ConsolidatedValuationReportContainer {
+    /**
+     * Id of the container.
+     */
+    id: number;
+    /**
+     * GUID of the container.
+     */
+    guid: string;
+    /**
+     * Name of the container.
+     */
+    name: string;
+}

package/reports/valuation/-valuation-report-consolidated.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/reports/valuation/-valuation-report-holdings-tree/-machinery.d.ts

@@ -0,0 +1,10 @@
+import { Decimal } from '@telostat/prelude';
+import { ValuationReportHolding, ValuationReportHoldingClassification } from '../-valuation-report-shared';
+import { ValuationReportHoldingsTreeNode, ValuationReportHoldingsTreeNodeValue } from './-types';
+export declare function makeValuationReportHoldingsTreeNodeValue(): ValuationReportHoldingsTreeNodeValue;
+export declare function updateTotals(nav: Decimal, investment: Decimal, tree: ValuationReportHoldingsTreeNode): ValuationReportHoldingsTreeNodeValue;
+export declare function resortChildren(node: ValuationReportHoldingsTreeNode): ValuationReportHoldingsTreeNode[];
+export declare function retreatTree(nav: Decimal, investment: Decimal, tree: ValuationReportHoldingsTreeNode): void;
+export declare function makeValuationReportHoldingsTreeNode(address: ValuationReportHoldingClassification): ValuationReportHoldingsTreeNode;
+export declare function addValuationReportHoldingToTree(tree: ValuationReportHoldingsTreeNode, address: ValuationReportHoldingClassification, holding: ValuationReportHolding): void;
+export declare function makeValuationReportHoldingsTree(nav: Decimal, investment: Decimal, holdings: ValuationReportHolding[]): ValuationReportHoldingsTreeNode;

package/reports/valuation/-valuation-report-holdings-tree/-machinery.js

@@ -0,0 +1,189 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeValuationReportHoldingsTree = exports.addValuationReportHoldingToTree = exports.makeValuationReportHoldingsTreeNode = exports.retreatTree = exports.resortChildren = exports.updateTotals = exports.makeValuationReportHoldingsTreeNodeValue = void 0;
+var prelude_1 = require("@telostat/prelude");
+var purify_ts_1 = require("purify-ts");
+var List_1 = require("purify-ts/List");
+var _utils_1 = require("./-utils");
+function makeValuationReportHoldingsTreeNodeValue() {
+    return {
+        investment: prelude_1.zero,
+        accrued: purify_ts_1.Nothing,
+        netValue: prelude_1.zero,
+        netValueRatio: prelude_1.zero,
+        absValue: prelude_1.zero,
+        absValueRatio: prelude_1.zero,
+        netExposure: prelude_1.zero,
+        netExposureRatio: prelude_1.zero,
+        absExposure: prelude_1.zero,
+        absExposureRatio: prelude_1.zero,
+        pnl: prelude_1.zero,
+        pnlRatio: prelude_1.zero,
+    };
+}
+exports.makeValuationReportHoldingsTreeNodeValue = makeValuationReportHoldingsTreeNodeValue;
+function updateTotals(nav, investment, tree) {
+    var holdings = tree.holdings;
+    var children = tree.children;
+    var netValue = (0, prelude_1.sumDecimals)(holdings.map(function (x) { return x.valuation.value.net.ref; })).add((0, prelude_1.sumDecimals)(children.map(function (x) { return x.totals.netValue; })));
+    var absValue = (0, prelude_1.sumDecimals)(holdings.map(function (x) { return x.valuation.value.abs.ref; })).add((0, prelude_1.sumDecimals)(children.map(function (x) { return x.totals.absValue; })));
+    var netExposure = (0, prelude_1.sumDecimals)(holdings.map(function (x) { return x.valuation.exposure.net.ref; })).add((0, prelude_1.sumDecimals)(children.map(function (x) { return x.totals.netExposure; })));
+    var absExposure = (0, prelude_1.sumDecimals)(holdings.map(function (x) { return x.valuation.exposure.abs.ref; })).add((0, prelude_1.sumDecimals)(children.map(function (x) { return x.totals.absExposure; })));
+    var pnl = (0, prelude_1.sumDecimals)(holdings.map(function (x) { return x.pnl; })).add((0, prelude_1.sumDecimals)(children.map(function (x) { return x.totals.pnl; })));
+    var accruedsHoldings = holdings.map(function (x) { return x.investment.accrued.map(function (x) { return x.ref; }); });
+    var accruedsChildren = children.map(function (x) { return x.totals.accrued; });
+    var accrueds = purify_ts_1.Maybe.catMaybes(__spreadArray(__spreadArray([], __read(accruedsHoldings), false), __read(accruedsChildren), false));
+    return {
+        investment: (0, prelude_1.sumDecimals)(holdings.map(function (x) { return x.investment.value.ref; })).add((0, prelude_1.sumDecimals)(children.map(function (x) { return x.totals.investment; }))),
+        accrued: accrueds.length === 0 ? purify_ts_1.Nothing : (0, purify_ts_1.Just)((0, prelude_1.sumDecimals)(accrueds)),
+        netValue: netValue,
+        netValueRatio: (0, prelude_1.safeDiv)(netValue, nav).orDefault(prelude_1.zero),
+        absValue: absValue,
+        absValueRatio: (0, prelude_1.safeDiv)(absValue, nav).orDefault(prelude_1.zero),
+        netExposure: netExposure,
+        netExposureRatio: (0, prelude_1.safeDiv)(netExposure, nav).orDefault(prelude_1.zero),
+        absExposure: absExposure,
+        absExposureRatio: (0, prelude_1.safeDiv)(absExposure, nav).orDefault(prelude_1.zero),
+        pnl: pnl,
+        pnlRatio: (0, prelude_1.safeDiv)(pnl, investment).orDefault(prelude_1.zero),
+    };
+}
+exports.updateTotals = updateTotals;
+function resortChildren(node) {
+    return node.children.sort(function (t1, t2) {
+        // Get current address segments:
+        var segment1 = List_1.List.last(t1.address);
+        var segment2 = List_1.List.last(t2.address);
+        // Compare and return:
+        return segment1
+            .chain(function (s1) { return segment2.chain(function (s2) { return (0, purify_ts_1.Just)((0, prelude_1.Tuple)(s1, s2)); }); })
+            .map(function (x) { return x.toArray(); })
+            .map(function (_a) {
+            var _b = __read(_a, 2), x = _b[0], y = _b[1];
+            return "".concat(x.order).localeCompare("".concat(y.order));
+        })
+            .orDefaultLazy(function () { return (segment1.isNothing() ? -1 : 1); });
+    });
+}
+exports.resortChildren = resortChildren;
+function retreatTree(nav, investment, tree) {
+    // First, retreat all children (recursive):
+    tree.children.forEach(function (x) { return retreatTree(nav, investment, x); });
+    // Recompute totals:
+    tree.totals = updateTotals(nav, investment, tree);
+    // Resort children:
+    tree.children = resortChildren(tree);
+}
+exports.retreatTree = retreatTree;
+function makeValuationReportHoldingsTreeNode(address) {
+    return {
+        name: List_1.List.last(address)
+            .map(function (x) { return x.name; })
+            .orDefault(''),
+        address: address,
+        holdings: [],
+        children: [],
+        totals: makeValuationReportHoldingsTreeNodeValue(),
+    };
+}
+exports.makeValuationReportHoldingsTreeNode = makeValuationReportHoldingsTreeNode;
+function addValuationReportHoldingToTree(tree, address, holding) {
+    var e_1, _a;
+    // Get the starting (current) node:
+    var node = tree;
+    // Iterate over address and traverse the tree while adding new nodes when required:
+    var sofar = [];
+    var sofarAddress = [];
+    try {
+        for (var address_1 = __values(address), address_1_1 = address_1.next(); !address_1_1.done; address_1_1 = address_1.next()) {
+            var segment = address_1_1.value;
+            // Append to address buffer:
+            sofar.push(segment.name);
+            sofarAddress.push(segment);
+            // Attempt to find the child:
+            var child = node.children.find(function (n) {
+                return (0, _utils_1.compareStringArrays)(n.address.map(function (x) { return x.name; }), sofar) === 0;
+            });
+            // Add or use?
+            if (child === undefined) {
+                // Create the new node:
+                child = makeValuationReportHoldingsTreeNode(__spreadArray([], __read(sofarAddress), false));
+                // Add the new node to the current node as a child:
+                node.children.push(child);
+            }
+            // Set the current node to the child:
+            node = child;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (address_1_1 && !address_1_1.done && (_a = address_1.return)) _a.call(address_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    // Done, we append the holding to the current node and return from the procedure:
+    node.holdings.push(holding);
+}
+exports.addValuationReportHoldingToTree = addValuationReportHoldingToTree;
+function makeValuationReportHoldingsTree(nav, investment, holdings) {
+    var e_2, _a;
+    // Initialize the tree:
+    var tree = makeValuationReportHoldingsTreeNode([]);
+    tree.name = '« Total »';
+    try {
+        // Iterate over the holdings and attempt to add to the tree:
+        for (var holdings_1 = __values(holdings), holdings_1_1 = holdings_1.next(); !holdings_1_1.done; holdings_1_1 = holdings_1.next()) {
+            var holding = holdings_1_1.value;
+            addValuationReportHoldingToTree(tree, holding.classification, holding);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (holdings_1_1 && !holdings_1_1.done && (_a = holdings_1.return)) _a.call(holdings_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    // Retreat the tree:
+    retreatTree(nav, investment, tree);
+    // Done, return:
+    return tree;
+}
+exports.makeValuationReportHoldingsTree = makeValuationReportHoldingsTree;

package/reports/valuation/-valuation-report-holdings-tree/-types.d.ts

@@ -0,0 +1,23 @@
+import { Decimal, Maybe } from '@telostat/prelude';
+import { ValuationReportHolding, ValuationReportHoldingClassification } from '../-valuation-report-shared';
+export interface ValuationReportHoldingsTreeNode {
+    name: string;
+    address: ValuationReportHoldingClassification;
+    holdings: ValuationReportHolding[];
+    children: ValuationReportHoldingsTreeNode[];
+    totals: ValuationReportHoldingsTreeNodeValue;
+}
+export interface ValuationReportHoldingsTreeNodeValue {
+    investment: Decimal;
+    accrued: Maybe<Decimal>;
+    netValue: Decimal;
+    netValueRatio: Decimal;
+    absValue: Decimal;
+    absValueRatio: Decimal;
+    netExposure: Decimal;
+    netExposureRatio: Decimal;
+    absExposure: Decimal;
+    absExposureRatio: Decimal;
+    pnl: Decimal;
+    pnlRatio: Decimal;
+}

package/reports/valuation/-valuation-report-holdings-tree/-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/reports/valuation/-valuation-report-holdings-tree/-utils.d.ts

@@ -0,0 +1 @@
+export declare function compareStringArrays(x: string[], y: string[]): number;

package/reports/valuation/-valuation-report-holdings-tree/-utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareStringArrays = void 0;
+function compareStringArrays(x, y) {
+    var xLen = x.length;
+    var yLen = y.length;
+    var minLength = Math.min(xLen, yLen);
+    for (var i = 0; i < minLength; i++) {
+        var comparison = (x[i] || '').localeCompare(y[i] || '');
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return Math.sign(xLen - yLen);
+}
+exports.compareStringArrays = compareStringArrays;

package/reports/valuation/-valuation-report-holdings-tree/index.d.ts

@@ -0,0 +1,2 @@
+export { makeValuationReportHoldingsTree } from './-machinery';
+export * from './-types';