@decafhub/decaf-client-extras 0.0.1

package/es/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/es/reports/valuation/-valuation-report-consolidated.js

@@ -0,0 +1 @@
+export {};

package/es/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/es/reports/valuation/-valuation-report-holdings-tree/-machinery.js

@@ -0,0 +1,116 @@
+import { safeDiv, sumDecimals, Tuple, zero } from '@telostat/prelude';
+import { Just, Maybe, Nothing } from 'purify-ts';
+import { List } from 'purify-ts/List';
+import { compareStringArrays } from './-utils';
+export function makeValuationReportHoldingsTreeNodeValue() {
+    return {
+        investment: zero,
+        accrued: Nothing,
+        netValue: zero,
+        netValueRatio: zero,
+        absValue: zero,
+        absValueRatio: zero,
+        netExposure: zero,
+        netExposureRatio: zero,
+        absExposure: zero,
+        absExposureRatio: zero,
+        pnl: zero,
+        pnlRatio: zero,
+    };
+}
+export function updateTotals(nav, investment, tree) {
+    const holdings = tree.holdings;
+    const children = tree.children;
+    const netValue = sumDecimals(holdings.map((x) => x.valuation.value.net.ref)).add(sumDecimals(children.map((x) => x.totals.netValue)));
+    const absValue = sumDecimals(holdings.map((x) => x.valuation.value.abs.ref)).add(sumDecimals(children.map((x) => x.totals.absValue)));
+    const netExposure = sumDecimals(holdings.map((x) => x.valuation.exposure.net.ref)).add(sumDecimals(children.map((x) => x.totals.netExposure)));
+    const absExposure = sumDecimals(holdings.map((x) => x.valuation.exposure.abs.ref)).add(sumDecimals(children.map((x) => x.totals.absExposure)));
+    const pnl = sumDecimals(holdings.map((x) => x.pnl)).add(sumDecimals(children.map((x) => x.totals.pnl)));
+    const accruedsHoldings = holdings.map((x) => x.investment.accrued.map((x) => x.ref));
+    const accruedsChildren = children.map((x) => x.totals.accrued);
+    const accrueds = Maybe.catMaybes([...accruedsHoldings, ...accruedsChildren]);
+    return {
+        investment: sumDecimals(holdings.map((x) => x.investment.value.ref)).add(sumDecimals(children.map((x) => x.totals.investment))),
+        accrued: accrueds.length === 0 ? Nothing : Just(sumDecimals(accrueds)),
+        netValue,
+        netValueRatio: safeDiv(netValue, nav).orDefault(zero),
+        absValue,
+        absValueRatio: safeDiv(absValue, nav).orDefault(zero),
+        netExposure,
+        netExposureRatio: safeDiv(netExposure, nav).orDefault(zero),
+        absExposure,
+        absExposureRatio: safeDiv(absExposure, nav).orDefault(zero),
+        pnl,
+        pnlRatio: safeDiv(pnl, investment).orDefault(zero),
+    };
+}
+export function resortChildren(node) {
+    return node.children.sort((t1, t2) => {
+        // Get current address segments:
+        const segment1 = List.last(t1.address);
+        const segment2 = List.last(t2.address);
+        // Compare and return:
+        return segment1
+            .chain((s1) => segment2.chain((s2) => Just(Tuple(s1, s2))))
+            .map((x) => x.toArray())
+            .map(([x, y]) => `${x.order}`.localeCompare(`${y.order}`))
+            .orDefaultLazy(() => (segment1.isNothing() ? -1 : 1));
+    });
+}
+export function retreatTree(nav, investment, tree) {
+    // First, retreat all children (recursive):
+    tree.children.forEach((x) => retreatTree(nav, investment, x));
+    // Recompute totals:
+    tree.totals = updateTotals(nav, investment, tree);
+    // Resort children:
+    tree.children = resortChildren(tree);
+}
+export function makeValuationReportHoldingsTreeNode(address) {
+    return {
+        name: List.last(address)
+            .map((x) => x.name)
+            .orDefault(''),
+        address,
+        holdings: [],
+        children: [],
+        totals: makeValuationReportHoldingsTreeNodeValue(),
+    };
+}
+export function addValuationReportHoldingToTree(tree, address, holding) {
+    // Get the starting (current) node:
+    let node = tree;
+    // Iterate over address and traverse the tree while adding new nodes when required:
+    const sofar = [];
+    const sofarAddress = [];
+    for (const segment of address) {
+        // Append to address buffer:
+        sofar.push(segment.name);
+        sofarAddress.push(segment);
+        // Attempt to find the child:
+        let child = node.children.find((n) => compareStringArrays(n.address.map((x) => x.name), sofar) === 0);
+        // Add or use?
+        if (child === undefined) {
+            // Create the new node:
+            child = makeValuationReportHoldingsTreeNode([...sofarAddress]);
+            // Add the new node to the current node as a child:
+            node.children.push(child);
+        }
+        // Set the current node to the child:
+        node = child;
+    }
+    // Done, we append the holding to the current node and return from the procedure:
+    node.holdings.push(holding);
+}
+export function makeValuationReportHoldingsTree(nav, investment, holdings) {
+    // Initialize the tree:
+    const tree = makeValuationReportHoldingsTreeNode([]);
+    tree.name = '« Total »';
+    // Iterate over the holdings and attempt to add to the tree:
+    for (const holding of holdings) {
+        addValuationReportHoldingToTree(tree, holding.classification, holding);
+    }
+    // Retreat the tree:
+    retreatTree(nav, investment, tree);
+    // Done, return:
+    return tree;
+}

package/es/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/es/reports/valuation/-valuation-report-holdings-tree/-types.js

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,12 @@
+export function compareStringArrays(x, y) {
+    const xLen = x.length;
+    const yLen = y.length;
+    const minLength = Math.min(xLen, yLen);
+    for (let i = 0; i < minLength; i++) {
+        const comparison = (x[i] || '').localeCompare(y[i] || '');
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return Math.sign(xLen - yLen);
+}

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

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

package/es/reports/valuation/-valuation-report-holdings-tree/index.js

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

package/es/reports/valuation/-valuation-report-portfolio.d.ts

@@ -0,0 +1,79 @@
+import { Decimal, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { ActionId, CurrencyCode, ExternalValuationId, OhlcSeriesId, PortfolioId, PrincipalId, ShareClassFeeScheduleId, ShareClassId } from '../../commons';
+import { BaseValuationReport, ValuationReportPortfolio } from './-valuation-report-shared';
+export interface PortfolioValuationReport extends BaseValuationReport {
+    portfolio: ValuationReportPortfolio;
+    subscriptions: Decimal;
+    shareClassValues: PortfolioValuationReportShareClassValue[];
+}
+export interface PortfolioValuationReportShareClassValue {
+    shareclass: PortfolioValuationReportShareClass;
+    external: Maybe<PortfolioValuationReportExternalValue>;
+    nav: Decimal;
+    navAdjusted: Decimal;
+    navAdjustedTotal: Decimal;
+    coefficient: Decimal;
+    gavRefccy: Decimal;
+    gavClsccy: Decimal;
+    sharecountPrev: Decimal;
+    sharecountCurr: Decimal;
+    sharecountDiff: Decimal;
+    pxRefCcy: Decimal;
+    pxClsCcy: Decimal;
+    ytdExt: Maybe<Decimal>;
+    ytdInt: Maybe<Decimal>;
+}
+export interface PortfolioValuationReportShareClass {
+    id: ShareClassId;
+    created: SDateTime;
+    creator: Maybe<PrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<PrincipalId>;
+    guid: string;
+    portfolio: PortfolioId;
+    name: string;
+    currency: CurrencyCode;
+    isin: Maybe<string>;
+    bbgticker: Maybe<string>;
+    liquidity: Maybe<string>;
+    jurisdiction: Maybe<string>;
+    administrator: Maybe<string>;
+    minimumInvestment: Maybe<string>;
+    subscriptionRedemptionPeriod: Maybe<string>;
+    managementFeeFrequency: Maybe<number>;
+    performanceFeeFrequency: Maybe<number>;
+    benchmark: Maybe<OhlcSeriesId>;
+    description: Maybe<string>;
+    feeScheduleIds: ShareClassFeeScheduleId[];
+    effectiveFeeScheduleId: Maybe<ShareClassFeeScheduleId>;
+    subscriptionIds: ActionId[];
+    outstanding: Maybe<Decimal>;
+}
+export interface PortfolioValuationReportExternalValue {
+    id: ExternalValuationId;
+    created: SDateTime;
+    creator: Maybe<PrincipalId>;
+    updated: SDateTime;
+    updater: Maybe<PrincipalId>;
+    guid: string;
+    portfolio: PortfolioId;
+    shareclass: Maybe<ShareClassId>;
+    date: SDate;
+    ccy: CurrencyCode;
+    shares: Maybe<Decimal>;
+    price: Maybe<Decimal>;
+    nav: Maybe<Decimal>;
+    aum: Maybe<Decimal>;
+    hedgepnl: Maybe<Decimal>;
+    feemngt: Maybe<Decimal>;
+    feeperf: Maybe<Decimal>;
+    otheraccrued: Maybe<Decimal>;
+    totalaccrued: Maybe<Decimal>;
+    subred: Maybe<Decimal>;
+    perfdaily: Maybe<Decimal>;
+    perfweekly: Maybe<Decimal>;
+    perfmonthly: Maybe<Decimal>;
+    perfytd: Maybe<Decimal>;
+    perfstart: Maybe<Decimal>;
+    coefficient: Maybe<Decimal>;
+}

package/es/reports/valuation/-valuation-report-portfolio.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,189 @@
+import { Decimal, Maybe, SDate, SDateTime } from '@telostat/prelude';
+import { AccountId, ArtifactId, ArtifactTypeId, CurrencyCode, DateType, PortfolioId } from '../../commons';
+/**
+ * Type definition for base valuation report.
+ */
+export interface BaseValuationReport {
+    asof: SDateTime;
+    date: SDate;
+    dateType: DateType;
+    currency: CurrencyCode;
+    accounts: ValuationReportAccounts;
+    holdings: ValuationReportHolding[];
+    accruals: ValuationReportAccrual[];
+    fxRates: ValuationReportFxRate[];
+    figures: {
+        investment: Decimal;
+        valuation: {
+            net: Decimal;
+            abs: Decimal;
+        };
+        accrued: Decimal;
+        liabilities: Decimal;
+        gav: Decimal;
+        nav: Decimal;
+        aum: Decimal;
+        pnl: Decimal;
+        pnlToInvestment?: Maybe<Decimal>;
+    };
+}
+/**
+ * Type definition for account reference in valuation reports.
+ */
+export interface ValuationReportAccount {
+    id: AccountId;
+    guid: string;
+    name: string;
+}
+/**
+ * Type definition for portfolio reference in valuation reports.
+ */
+export interface ValuationReportPortfolio {
+    id: PortfolioId;
+    guid: string;
+    name: string;
+}
+/**
+ * Type definition for accounts which valuation report is compiled from.
+ */
+export interface ValuationReportAccounts {
+    custody: ValuationReportAccount[];
+    journal: ValuationReportAccount[];
+}
+/**
+ * The definition for valuation report holding classification.
+ */
+export declare type ValuationReportHoldingClassification = ValuationReportHoldingClassificationNode[];
+/**
+ * Type definition for valuation report holding classification node.
+ */
+export interface ValuationReportHoldingClassificationNode {
+    name: string;
+    order: string | number;
+}
+/**
+ * Type definition for base valuation report holding (shared by
+ * [[ValuationReportHolding]] and [[ValuationReportChildHolding]]).
+ */
+export interface BaseValuationReportHolding {
+    artifact: ValuationReportArtifact;
+    quantity: Decimal;
+    investment: ValuationReportHoldingFiguresInvestment;
+    valuation: ValuationReportHoldingFiguresValuation;
+    valuePercentage: Maybe<Decimal>;
+    netExposurePercentage: Maybe<Decimal>;
+    absExposurePercentage: Maybe<Decimal>;
+    change: Maybe<Decimal>;
+    pnl: Decimal;
+    pnlToInvestment: Maybe<Decimal>;
+    opendate: SDate;
+    lastdate: SDate;
+}
+/**
+ * Type definition for valuation report holding investment figures.
+ */
+export interface ValuationReportHoldingFiguresInvestment {
+    px: ValuationReportFigureOrgRef;
+    txncosts: Maybe<ValuationReportFigureOrgRef>;
+    accrued: Maybe<ValuationReportFigureOrgRef>;
+    value: ValuationReportFigureOrgRef;
+}
+/**
+ * Type definition for valuation report holding valuation figures.
+ */
+export interface ValuationReportHoldingFiguresValuation {
+    px: ValuationReportFigureOrgRef;
+    accrued: Maybe<ValuationReportFigureOrgRef>;
+    value: {
+        net: ValuationReportFigureOrgRef;
+        abs: ValuationReportFigureOrgRef;
+    };
+    exposure: {
+        net: ValuationReportFigureOrgRef;
+        abs: ValuationReportFigureOrgRef;
+    };
+}
+/**
+ * Type definition for valuation report figure value that is reported both in
+ * original currency and reference currency.
+ */
+export interface ValuationReportFigureOrgRef {
+    org: Decimal;
+    ref: Decimal;
+}
+/**
+ * Type definition for a valuation holding.
+ */
+export interface ValuationReportHolding extends BaseValuationReportHolding {
+    classification: ValuationReportHoldingClassification;
+    accounts: ValuationReportAccount[];
+    children: Maybe<ValuationReportChildHolding[]>;
+}
+/**
+ * Type definition for a valuation holding child.
+ */
+export interface ValuationReportChildHolding extends BaseValuationReportHolding {
+    account: ValuationReportAccount;
+}
+export declare function isValuationHolding(x: ValuationReportHolding | ValuationReportChildHolding): x is ValuationReportHolding;
+export declare function isValuationChildHolding(x: ValuationReportHolding | ValuationReportChildHolding): x is ValuationReportChildHolding;
+/**
+ * Valuation accrual.
+ */
+export interface ValuationReportAccrual {
+    name: string;
+    value: Decimal;
+    accounts: ValuationReportAccrualByAccount[];
+}
+/**
+ * Valuation accrual by account.
+ */
+export interface ValuationReportAccrualByAccount {
+    account: ValuationReportAccount;
+    value: Decimal;
+    accruals: ValuationReportAccrualByCurrency[];
+}
+/**
+ * Valuation accrual by account by currency.
+ */
+export interface ValuationReportAccrualByCurrency {
+    artifact: ValuationReportArtifact;
+    ccy: CurrencyCode;
+    value: ValuationReportFigureOrgRef;
+}
+/**
+ * Type definition of the FINREA artifact type.
+ */
+export interface ValuationReportArtifactType {
+    id: ArtifactTypeId;
+    name: string;
+    order: number;
+}
+/**
+ * Type definition for the artifact as reported in the valuation.
+ */
+export interface ValuationReportArtifact {
+    id: ArtifactId;
+    guid: string;
+    type: ValuationReportArtifactType;
+    stype: Maybe<string>;
+    symbol: string;
+    name: Maybe<string>;
+    ccy: Maybe<CurrencyCode>;
+    quantity: Decimal;
+    country: Maybe<string>;
+    issuer: Maybe<string>;
+    sector: Maybe<string>;
+    mic: Maybe<string>;
+    ticker: Maybe<string>;
+    isin: Maybe<string>;
+    figi: Maybe<string>;
+    expiry: Maybe<SDate>;
+    underlyingId: Maybe<ArtifactId>;
+}
+export interface ValuationReportFxRate {
+    ccy1: CurrencyCode;
+    ccy2: CurrencyCode;
+    value: Decimal;
+    asof: SDate;
+}

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

@@ -0,0 +1,6 @@
+export function isValuationHolding(x) {
+    return 'accounts' in x;
+}
+export function isValuationChildHolding(x) {
+    return 'account' in x;
+}

package/es/reports/valuation/index.d.ts

@@ -0,0 +1,8 @@
+export { fetchConsolidatedValuationReport } from './-remote-valuation-report-consolidated';
+export type { ConsolidatedValuationReportQuery } from './-remote-valuation-report-consolidated';
+export { fetchPortfolioValuationReport } from './-remote-valuation-report-portfolio';
+export type { PortfolioValuationReportQuery } from './-remote-valuation-report-portfolio';
+export * from './-valuation-report-consolidated';
+export * from './-valuation-report-holdings-tree';
+export * from './-valuation-report-portfolio';
+export * from './-valuation-report-shared';

package/es/reports/valuation/index.js

@@ -0,0 +1,6 @@
+export { fetchConsolidatedValuationReport } from './-remote-valuation-report-consolidated';
+export { fetchPortfolioValuationReport } from './-remote-valuation-report-portfolio';
+export * from './-valuation-report-consolidated';
+export * from './-valuation-report-holdings-tree';
+export * from './-valuation-report-portfolio';
+export * from './-valuation-report-shared';

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './commons';
+export * as commons from './commons';
+export * as reports from './reports';

package/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reports = exports.commons = void 0;
+__exportStar(require("./commons"), exports);
+exports.commons = __importStar(require("./commons"));
+exports.reports = __importStar(require("./reports"));

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  setupFiles: ['dotenv/config'],
+};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@decafhub/decaf-client-extras",
+  "version": "0.0.1",
+  "description": "DECAF Client Extras",
+  "author": "Teloscube Pte Ltd",
+  "license": "MIT",
+  "private": false,
+  "repository": {
+    "url": "https://github.com/teloscube/decaf-client-javascript-extras",
+    "type": "git"
+  },
+  "homepage": "https://github.com/teloscube/decaf-client-javascript-extras",
+  "source": "./src/index.ts",
+  "main": "./index.js",
+  "module": "./es/index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "start": "tsc --watch",
+    "test": "jest",
+    "build": "rm -rf lib && tsc && tsc -p tsconfig.es.json && yarn make:docs",
+    "make:docs": "typedoc",
+    "deploy:docs": "gh-pages -d ./docs",
+    "prepare": "yarn build && ./postinstall.sh"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "peerDependencies": {
+    "@decafhub/decaf-client": "~0.2"
+  },
+  "dependencies": {
+    "@telostat/prelude": "^0.1.1"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^17.0.3",
+    "@commitlint/config-conventional": "^17.0.3",
+    "@decafhub/decaf-client": "^0.2.2",
+    "@types/jest": "^28.1.6",
+    "@types/node": "^18.6.1",
+    "@typescript-eslint/eslint-plugin": "^5.30.7",
+    "@typescript-eslint/parser": "^5.30.7",
+    "dotenv": "^16.0.1",
+    "eslint": "^8.20.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-standard": "^17.0.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.2.4",
+    "eslint-plugin-prettier": "^4.2.1",
+    "eslint-plugin-promise": "^6.0.0",
+    "eslint-plugin-standard": "^5.0.0",
+    "gh-pages": "^4.0.0",
+    "husky": "^8.0.0",
+    "jest": "^28.1.3",
+    "lint-staged": "^13.0.3",
+    "prettier": "^2.7.1",
+    "ts-jest": "^28.0.7",
+    "typedoc": "^0.23.9",
+    "typescript": "^4.7.4"
+  },
+  "lint-staged": {
+    "src/**/*.{ts,tsx}": [
+      "./node_modules/.bin/prettier --write",
+      "./node_modules/.bin/eslint"
+    ]
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "printWidth": 120,
+    "useTabs": false,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "es5"
+  },
+  "commitlint": {
+    "extends": [
+      "@commitlint/config-conventional"
+    ]
+  }
+}

package/postinstall.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -e
+
+if [ -f .env ]; then
+  source .env
+fi
+
+if [ -n "$DECAF_JS_SKIP_POSTINSTALL" ]; then
+  yarn husky install
+  echo "Local Env detected. Skipping lib/ relocation..."
+  exit 0
+fi
+
+echo 'Copying files from lib folder into root project folder...'
+cp -r lib/* ./ && rm -rf lib
+echo 'Done!'

package/release-please-config.json

@@ -0,0 +1,9 @@
+{
+  "packages": {
+    ".": {
+      "bump-minor-pre-major": true,
+      "bump-patch-for-minor-pre-major": true,
+      "release-type": "node"
+    }
+  }
+}

package/reports/index.d.ts

@@ -0,0 +1 @@
+export * as valuation from './valuation';