Diffusion Cost Calculator Source code (PostProjectCosts) Browse

costcalc/js/money.js
590f0d321eb1PostProjectCosts

money.js
View Options

			/*!
			* money.js / fx() v0.2
			* Copyright 2014 Open Exchange Rates
			*
			* JavaScript library for realtime currency conversion and exchange rate calculation.
			*
			* Freely distributable under the MIT license.
			* Portions of money.js are inspired by or borrowed from underscore.js
			*
			* For details, examples and documentation:
			* http://openexchangerates.github.io/money.js/
			*/

			(function (root, _undefined) {
			// Create a safe reference to the money.js object for use below.
			const fx = function (obj) {
			return new FxWrapper(obj)
			}

			// Current version.
			fx.version = '0.2'

			/* --- Setup --- */

			// fxSetup can be defined before loading money.js, to set the exchange rates and the base
			// (and default from/to) currencies - or the rates can be loaded in later if needed.
			const fxSetup = root.fxSetup \|\| {
			rates: {},
			base: ''
			}

			// Object containing exchange rates relative to the fx.base currency, eg { "GBP" : "0.64" }
			fx.rates = fxSetup.rates

			// Default exchange rate base currency (eg "USD"), which all the exchange rates are relative to
			fx.base = fxSetup.base

			// Default from / to currencies for conversion via fx.convert():
			fx.settings = {
			from: fxSetup.from \|\| fx.base,
			to: fxSetup.to \|\| fx.base
			}

			/* --- Conversion --- */

			// The base function of the library: converts a value from one currency to another
			const convert = fx.convert = function (val, opts) {
			// Convert arrays recursively
			if (typeof val === 'object' && val.length) {
			for (let i = 0; i < val.length; i++) {
			val[i] = convert(val[i], opts)
			}
			return val
			}

			// Make sure we gots some opts
			opts = opts \|\| {}

			// We need to know the `from` and `to` currencies
			if (!opts.from) opts.from = fx.settings.from
			if (!opts.to) opts.to = fx.settings.to

			// Multiple the value by the exchange rate
			return val * getRate(opts.to, opts.from)
			}

			// Returns the exchange rate to `target` currency from `base` currency
			const getRate = function (to, from) {
			// Save bytes in minified version
			const rates = fx.rates

			// Make sure the base rate is in the rates object:
			rates[fx.base] = 1

			// Throw an error if either rate isn't in the rates array
			if (!rates[to] \|\| !rates[from]) throw new Error('fx error')

			// If `from` currency === fx.base, return the basic exchange rate for the `to` currency
			if (from === fx.base) {
			return rates[to]
			}

			// If `to` currency === fx.base, return the basic inverse rate of the `from` currency
			if (to === fx.base) {
			return 1 / rates[from]
			}

			// Otherwise, return the `to` rate multipled by the inverse of the `from` rate to get the
			// relative exchange rate between the two currencies
			return rates[to] * (1 / rates[from])
			}

			/* --- OOP wrapper and chaining --- */

			// If fx(val) is called as a function, it returns a wrapped object that can be used OO-style
			const FxWrapper = function (val) {
			// Experimental: parse strings to pull out currency code and value:
			if (typeof val === 'string') {
			this._v = parseFloat(val.replace(/[^0-9-.]/g, ''))
			this._fx = val.replace(/([^A-Za-z])/g, '')
			} else {
			this._v = val
			}
			}

			// Expose `wrapper.prototype` as `fx.prototype`
			const fxProto = fx.prototype = FxWrapper.prototype

			// fx(val).convert(opts) does the same thing as fx.convert(val, opts)
			fxProto.convert = function () {
			const args = Array.prototype.slice.call(arguments)
			args.unshift(this._v)
			return convert.apply(fx, args)
			}

			// fx(val).from(currency) returns a wrapped `fx` where the value has been converted from
			// `currency` to the `fx.base` currency. Should be followed by `.to(otherCurrency)`
			fxProto.from = function (currency) {
			const wrapped = fx(convert(this._v, { from: currency, to: fx.base }))
			wrapped._fx = fx.base
			return wrapped
			}

			// fx(val).to(currency) returns the value, converted from `fx.base` to `currency`
			fxProto.to = function (currency) {
			return convert(this._v, { from: this._fx ? this._fx : fx.settings.from, to: currency })
			}

			/* --- Module Definition --- */

			// Export the fx object for CommonJS.
			// Otherwise, just add `fx` to the global object
			if (typeof exports !== 'undefined') {
			if (typeof module !== 'undefined' && module.exports) {
			exports = module.exports = fx
			}
			exports.fx = fx
			} else {
			// Use fx.noConflict to restore `fx` back to its original value before money.js loaded.
			// Returns a reference to the library's `fx` object; e.g. `var money = fx.noConflict();`
			fx.noConflict = (function (previousFx) {
			return function () {
			// Reset the value of the root's `fx` variable:
			root.fx = previousFx
			// Delete the noConflict function:
			fx.noConflict = _undefined
			// Return reference to the library to re-assign it:
			return fx
			}
			})(root.fx)

			// Declare `fx` on the root (global/window) object:
			root.fx = fx
			}

			// Root will be `window` in browser or `global` on the server:
			}(this))