@barchart/portfolio-api-common 1.0.1

package/gulpfile.js

@@ -0,0 +1,129 @@
+const gulp = require('gulp');
+
+const browserify = require('browserify'),
+	buffer = require('vinyl-buffer'),
+	bump = require('gulp-bump'),
+	exec = require('child_process').exec,
+	git = require('gulp-git'),
+	gitStatus = require('git-get-status'),
+	glob = require('glob'),
+	jasmine = require('gulp-jasmine'),
+	jshint = require('gulp-jshint'),
+	runSequence = require('run-sequence'),
+	source = require('vinyl-source-stream'),
+	util = require('gulp-util');
+
+const fs = require('fs');
+
+function getVersionFromPackage() {
+    return JSON.parse(fs.readFileSync('./package.json', 'utf8')).version;
+}
+
+gulp.task('ensure-clean-working-directory', () => {
+	gitStatus(function(err, status) {
+		if (err, !status.clean) {
+			throw new Error('Unable to proceed, your working directory is not clean.');
+		}
+	});
+});
+
+gulp.task('bump-version', () => {
+    return gulp.src([ './package.json' ])
+        .pipe(bump({ type: 'patch' }).on('error', util.log))
+        .pipe(gulp.dest('./'));
+});
+
+gulp.task('document', function (cb) {
+	exec('jsdoc . -c jsdoc.json -r -d docs', (error, stdout, stderr) => {
+		console.log(stdout);
+		console.log(stderr);
+
+		cb();
+	});
+});
+
+gulp.task('commit-changes', () => {
+    return gulp.src([ './', './test/', './package.json' ])
+        .pipe(git.add())
+        .pipe(git.commit('Release. Bump version number'));
+});
+
+gulp.task('push-changes', (cb) => {
+    git.push('origin', 'master', cb);
+});
+
+gulp.task('create-tag', (cb) => {
+    const version = getVersionFromPackage();
+
+    git.tag(version, 'Release ' + version, function (error) {
+        if (error) {
+            return cb(error);
+        }
+
+        git.push('origin', 'master', { args: '--tags' }, cb);
+    });
+});
+
+gulp.task('build-test-bundle', () => {
+	return browserify({ entries: glob.sync('test/specs/**/*.js') })
+		.bundle()
+		.pipe(source('SpecRunner.js'))
+		.pipe(buffer())
+		.pipe(gulp.dest('test'));
+});
+
+gulp.task('execute-browser-tests', () => {
+    return gulp.src('test/SpecRunner.js')
+        .pipe(jasmine());
+});
+
+gulp.task('execute-node-tests', () => {
+    return gulp.src(['test/specs/**/*.js'])
+        .pipe(jasmine());
+});
+
+gulp.task('execute-tests', (cb) => {
+    runSequence(
+        'build-test-bundle',
+        'execute-browser-tests',
+        'execute-node-tests',
+
+        function (error) {
+            if (error) {
+                console.log(error.message);
+            }
+
+            cb(error);
+        });
+});
+
+gulp.task('release', (cb) => {
+    runSequence(
+        'ensure-clean-working-directory',
+        'execute-tests',
+		'document',
+        'bump-version',
+        'commit-changes',
+        'push-changes',
+        'create-tag',
+
+        function (error) {
+            if (error) {
+                console.log(error.message);
+            } else {
+                console.log('Release complete');
+            }
+
+            cb(error);
+        });
+});
+
+gulp.task('lint', () => {
+    return gulp.src([ './**/*.js', './test/specs/**/*.js', '!./node_modules/**', '!./docs/**', '!./test/SpecRunner.js' ])
+        .pipe(jshint({'esversion': 6}))
+        .pipe(jshint.reporter('default'));
+});
+
+gulp.task('test', [ 'execute-tests' ]);
+
+gulp.task('default', [ 'lint' ]);

package/jsdoc.json

@@ -0,0 +1,8 @@
+{
+    "source": {
+        "include": [ "." ],
+        "exclude": [ "./node_modules", "./test" ],
+        "includePattern": ".+\\.js(doc|x)?$",
+        "excludePattern": "(^|\\/|\\\\)_"
+    }
+}

package/lib/data/CorporateActionType.js

@@ -0,0 +1,36 @@
+const Enum = require('@barchart/common-js/lang/Enum'),
+	is = require('@barchart/common-js/lang/is');
+
+module.exports = (() => {
+	'use strict';
+
+	class CorporateActionType extends Enum {
+		constructor(code, description, internal) {
+			super(code, description);
+
+			this._internal = is.boolean(internal) && internal;
+		}
+
+		get internal() {
+			return this._internal;
+		}
+
+		static get DIVIDEND() {
+			return dividend;
+		}
+
+		static get SPLIT() {
+			return split;
+		}
+
+		static get JOB() {
+			return job;
+		}
+	}
+
+	const dividend = new CorporateActionType('DIVIDEND', 'Dividend', false);
+	const split = new CorporateActionType('SPLIT', 'Split', false);
+	const job = new CorporateActionType('JOB', 'Job', true);
+
+	return CorporateActionType;
+})();

package/lib/data/InstrumentType.js

@@ -0,0 +1,83 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	Enum = require('@barchart/common-js/lang/Enum');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * An enumeration used to classify instruments.
+	 *
+	 * @public
+	 * @extends {Enum}
+	 * @param {String} description
+	 * @param {String} code
+	 * @param {Boolean} canReinvest
+	 */
+	class InstrumentType extends Enum {
+		constructor(code, description, canReinvest) {
+			super(code, description);
+
+			this._canReinvest = canReinvest;
+		}
+
+		/**
+		 * Indicates if the instrument type allows automatic reinvestment.
+		 *
+		 * @returns {Boolean}
+		 */
+		get canReinvest() {
+			return this._canReinvest;
+		}
+
+		/**
+		 * Cash.
+		 *
+		 * @public
+		 * @returns {InstrumentType}
+		 */
+		static get CASH() {
+			return cash;
+		}
+
+		/**
+		 * An equity issue.
+		 *
+		 * @public
+		 * @returns {InstrumentType}
+		 */
+		static get EQUITY() {
+			return equity;
+		}
+
+		/**
+		 * A mutual fund.
+		 *
+		 * @public
+		 * @returns {InstrumentType}
+		 */
+		static get FUND() {
+			return fund;
+		}
+
+		/**
+		 * An undefined asset (e.g. a house, or a collectible, or a salvaged alien spaceship).
+		 *
+		 * @public
+		 * @returns {InstrumentType}
+		 */
+		static get OTHER() {
+			return other;
+		}
+
+		toString() {
+			return '[InstrumentType]';
+		}
+	}
+
+	const cash = new InstrumentType('CASH', 'cash', false);
+	const equity = new InstrumentType('EQUITY', 'equity', true);
+	const fund = new InstrumentType('FUND', 'mutual fund', true);
+	const other = new InstrumentType('OTHER', 'other', false);
+
+	return InstrumentType;
+})();

package/lib/data/PositionSummaryFrame.js

@@ -0,0 +1,72 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	Enum = require('@barchart/common-js/lang/Enum');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * An enumeration used to define timeframes for position summaries.
+	 *
+	 * @public
+	 * @extends {Enum}
+	 * @param {String} description
+	 * @param {String} code
+	 * @param {Boolean} canReinvest
+	 */
+	class PositionSummaryFrame extends Enum {
+		constructor(code, description) {
+			super(code, description);
+		}
+
+		/**
+		 * A summary for a calendar year.
+		 *
+		 * @public
+		 * @returns {PositionSummaryFrame}
+		 */
+		static get YEARLY() {
+			return yearly;
+		}
+
+		/**
+		 * A summary for a quarter.
+		 *
+		 * @public
+		 * @returns {PositionSummaryFrame}
+		 */
+		static get QUARTERLY() {
+			return quarterly;
+		}
+
+		/**
+		 * A summary for a calendar month.
+		 *
+		 * @public
+		 * @returns {PositionSummaryFrame}
+		 */
+		static get MONTHLY() {
+			return monthly;
+		}
+
+		/**
+		 * A summary the current year (to date).
+		 *
+		 * @public
+		 * @returns {PositionSummaryFrame}
+		 */
+		static get YTD() {
+			return ytd;
+		}
+
+		toString() {
+			return '[PositionSummaryFrame]';
+		}
+	}
+
+	const yearly = new PositionSummaryFrame('YEARL', 'year');
+	const quarterly = new PositionSummaryFrame('QUARTER', 'quarter');
+	const monthly = new PositionSummaryFrame('MONTH', 'month');
+	const ytd = new PositionSummaryFrame('YTD', 'year-to-date');
+
+	return PositionSummaryFrame;
+})();

package/lib/data/TransactionType.js

@@ -0,0 +1,325 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	Enum = require('@barchart/common-js/lang/Enum');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * An enumeration item that describes a type of transaction.
+	 *
+	 * @public
+	 * @extends {Enum}
+	 * @param {String} code
+	 * @param {String} description
+	 * @param {Boolean} purchase
+	 * @param {Boolean} sale
+	 * @param {Boolean} income
+	 * @param {Boolean} opening
+	 * @param {Boolean} closing
+	 */
+	class TransactionType extends Enum {
+		constructor(code, description, purchase, sale, income, opening, closing) {
+			super(code, description);
+
+			assert.argumentIsRequired(purchase, 'purchase', Boolean);
+			assert.argumentIsRequired(sale, 'sale', Boolean);
+			assert.argumentIsRequired(income, 'income', Boolean);
+			assert.argumentIsRequired(opening, 'opening', Boolean);
+			assert.argumentIsRequired(closing, 'closing', Boolean);
+
+			this._purchase = purchase;
+			this._sale = sale;
+			this._income = income;
+			this._opening = opening;
+			this._closing = closing;
+		}
+
+		/**
+		 * Indicates if the transaction was a trade.
+		 *
+		 * @public
+		 * @returns {Boolean}
+		 */
+		get trade() {
+			return this._purchase || this._sale;
+		}
+
+		/**
+		 * Indicates if the trade was a purchase.
+		 *
+		 * @public
+		 * @returns {Boolean}
+		 */
+		get purchase() {
+			return this._purchase;
+		}
+
+		/**
+		 * Indicates if the trade was a sale.
+		 *
+		 * @public
+		 * @returns {Boolean}
+		 */
+		get sale() {
+			return this._sale;
+		}
+
+		/**
+		 * Indicates if the transaction was an income payment.
+		 *
+		 * @public
+		 * @returns {Boolean}
+		 */
+		get income() {
+			return this._income;
+		}
+
+		/**
+		 * Indicates if the transactions opens the position (i.e. increases its
+		 * magnitude).
+		 *
+		 * @public
+		 * @returns {Boolean}
+		 */
+		get opening() {
+			return this._opening;
+		}
+
+		/**
+		 * Indicates if the transactions closes the position (i.e. decreases its
+		 * magnitude).
+		 *
+		 * @public
+		 * @returns {Boolean}
+		 */
+		get closing() {
+			return this._closing;
+		}
+
+		/**
+		 * A purchase.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get BUY() {
+			return buy;
+		}
+
+		/**
+		 * A sale.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get SELL() {
+			return sell;
+		}
+
+		/**
+		 * A purchase (in a short position).
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get BUY_SHORT() {
+			return buyShort;
+		}
+
+		/**
+		 * A short sale.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get SELL_SHORT() {
+			return sellShort;
+		}
+
+		/**
+		 * A cash dividend.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get DIVIDEND() {
+			return dividend;
+		}
+
+		/**
+		 * A cash dividend, reinvested.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get DIVIDEND_REINVEST() {
+			return dividendReinvest;
+		}
+
+		/**
+		 * A stock dividend.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get DIVIDEND_STOCK() {
+			return dividendStock;
+		}
+
+		/**
+		 * A mutual fund distribution in cash.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get DISTRIBUTION_CASH() {
+			return distributionCash;
+		}
+
+		/**
+		 * A mutual fund distribution in units.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get DISTRIBUTION_FUND() {
+			return distributionFund;
+		}
+
+		/**
+		 * A split.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get SPLIT() {
+			return split;
+		}
+
+		/**
+		 * A fee.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get FEE() {
+			return fee;
+		}
+
+		/**
+		 * A mutual fund fee, which is paid in units.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get FEE_UNITS() {
+			return feeUnits;
+		}
+
+		/**
+		 * A deposit.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get DEPOSIT() {
+			return deposit;
+		}
+
+		/**
+		 * A withdrawal.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get WITHDRAWAL() {
+			return withdrawal;
+		}
+
+		/**
+		 * A system-generated withdrawal, arising from another transaction.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get DEBIT() {
+			return debit;
+		}
+
+		/**
+		 * A system-generated deposit, arising from another transaction.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get CREDIT() {
+			return credit;
+		}
+
+		/**
+		 * A valuation event.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get VALUATION() {
+			return valuation;
+		}
+
+		/**
+		 * Other Income.
+		 *
+		 * @public
+		 * @static
+		 * @returns {TransactionType}
+		 */
+		static get INCOME() {
+			return income;
+		}
+
+		toString() {
+			return '[TransactionType]';
+		}
+	}
+
+	const buy = new TransactionType('B', 'Buy', true, false, false, true,  false);
+	const sell = new TransactionType('S', 'Sell', false, true, false, false, true);
+	const buyShort = new TransactionType('BS', 'Buy To Cover', true, false, false, false, true);
+	const sellShort = new TransactionType('SS', 'Sell Short',  false, true, false, true, false);
+	const dividend = new TransactionType('DV', 'Dividend', false, false, true, false, false);
+	const dividendReinvest = new TransactionType('DR', 'Dividend (Reinvested)', false, false, false, true, false);
+	const dividendStock = new TransactionType('DS', 'Dividend (Stock)', false, false, false, true, false);
+	const split = new TransactionType('SP', 'Split', false, false, false, true, false);
+	const fee = new TransactionType('F', 'Fee', false, false, false, true, false);
+	const feeUnits = new TransactionType('FU', 'Fee', false, false, false, false, false);
+
+	const distributionCash = new TransactionType('DC', 'Distribution (Cash)', false, false, true, false, false);
+	const distributionFund = new TransactionType('DF', 'Distribution (Units)', false, false, false, true, false);
+
+	const deposit = new TransactionType('D', 'Deposit', false, false, false, false, false);
+	const withdrawal = new TransactionType('W', 'Withdrawal', false, false, false, false, false);
+	const debit = new TransactionType('DR', 'Debit', false, false, false, false, false);
+	const credit = new TransactionType('CR', 'Credit', false, false, false, false, false);
+
+	const valuation = new TransactionType('V', 'Valuation', false, false, false, false, false);
+	const income = new TransactionType('I', 'Income', false, false, true, false, false);
+
+	return TransactionType;
+})();

package/lib/data/ValuationType.js

@@ -0,0 +1,60 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	Enum = require('@barchart/common-js/lang/Enum');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * An enumeration item that describes a strategy for calculating basis.
+	 *
+	 * @public
+	 * @extends {Enum}
+	 * @param {String} description
+	 * @param {String} code
+	 */
+	class ValuationType extends Enum {
+		constructor(code, description) {
+			super(code, description);
+		}
+
+		/**
+		 * Given a code, returns the enumeration item.
+		 *
+		 * @public
+		 * @param {String} code
+		 * @returns {ValuationType|null}
+		 */
+		static parse(code) {
+			return Enum.fromCode(ValuationType, code);
+		}
+
+		/**
+		 * A valuation method that uses average costing.
+		 *
+		 * @public
+		 * @returns {ValuationType}
+		 */
+		static get AVERAGE_COST() {
+			return averageCost;
+		}
+
+		/**
+		 * A valuation method that uses first-in, first-out methodology.
+		 *
+		 * @public
+		 * @returns {ValuationType}
+		 */
+		static get FIFO() {
+			return fifo;
+		}
+
+		toString() {
+			return '[ValuationType]';
+		}
+	}
+
+	const fifo = new ValuationType('FIFO', 'first in, first out');
+	const averageCost = new ValuationType('AVG', 'average cost');
+
+	return ValuationType;
+})();