@attocash/cli 0.1.0

package/node_modules/@js-joda/core/src/format/ResolverStyle.js

@@ -0,0 +1,93 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {Enum} from '../Enum';
+
+/**
+ * Enumeration of different ways to resolve dates and times.
+ * 
+ * Parsing a text string occurs in two phases.
+ * Phase 1 is a basic text parse according to the fields added to the builder.
+ * Phase 2 resolves the parsed field-value pairs into date and/or time objects.
+ * This style is used to control how phase 2, resolving, happens.
+ *
+ * ### Static properties of Class {@link DateTimeFormatter}
+ *
+ * ResolverStyle.STRICT = new ResolverStyle('STRICT');
+ *
+ * Style to resolve dates and times strictly.
+ *
+ * Using strict resolution will ensure that all parsed values are within
+ * the outer range of valid values for the field. Individual fields may
+ * be further processed for strictness.
+ *
+ * For example, resolving year-month and day-of-month in the ISO calendar
+ * system using strict mode will ensure that the day-of-month is valid
+ * for the year-month, rejecting invalid values.
+ *
+ * ResolverStyle.SMART = new ResolverStyle('SMART');
+ *
+ * Style to resolve dates and times in a smart, or intelligent, manner.
+ *
+ * Using smart resolution will perform the sensible default for each
+ * field, which may be the same as strict, the same as lenient, or a third
+ * behavior. Individual fields will interpret this differently.
+ *
+ * For example, resolving year-month and day-of-month in the ISO calendar
+ * system using smart mode will ensure that the day-of-month is from
+ * 1 to 31, converting any value beyond the last valid day-of-month to be
+ * the last valid day-of-month.
+ *
+ * ResolverStyle.LENIENT = new ResolverStyle('LENIENT');
+ *
+ * Style to resolve dates and times leniently.
+ *
+ * Using lenient resolution will resolve the values in an appropriate
+ * lenient manner. Individual fields will interpret this differently.
+ *
+ * For example, lenient mode allows the month in the ISO calendar system
+ * to be outside the range 1 to 12.
+ * For example, month 15 is treated as being 3 months after month 12.
+ *
+ */
+export class ResolverStyle extends Enum {}
+
+/**
+ * Style to resolve dates and times strictly.
+ * 
+ * Using strict resolution will ensure that all parsed values are within
+ * the outer range of valid values for the field. Individual fields may
+ * be further processed for strictness.
+ * 
+ * For example, resolving year-month and day-of-month in the ISO calendar
+ * system using strict mode will ensure that the day-of-month is valid
+ * for the year-month, rejecting invalid values.
+ */
+ResolverStyle.STRICT = new ResolverStyle('STRICT');
+/**
+ * Style to resolve dates and times in a smart, or intelligent, manner.
+ * 
+ * Using smart resolution will perform the sensible default for each
+ * field, which may be the same as strict, the same as lenient, or a third
+ * behavior. Individual fields will interpret this differently.
+ * 
+ * For example, resolving year-month and day-of-month in the ISO calendar
+ * system using smart mode will ensure that the day-of-month is from
+ * 1 to 31, converting any value beyond the last valid day-of-month to be
+ * the last valid day-of-month.
+ */
+ResolverStyle.SMART = new ResolverStyle('SMART');
+/**
+ * Style to resolve dates and times leniently.
+ * 
+ * Using lenient resolution will resolve the values in an appropriate
+ * lenient manner. Individual fields will interpret this differently.
+ * 
+ * For example, lenient mode allows the month in the ISO calendar system
+ * to be outside the range 1 to 12.
+ * For example, month 15 is treated as being 3 months after month 12.
+ */
+ResolverStyle.LENIENT = new ResolverStyle('LENIENT');

package/node_modules/@js-joda/core/src/format/SignStyle.js

@@ -0,0 +1,38 @@
+/**
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {Enum} from '../Enum';
+
+export class SignStyle extends Enum{
+    /**
+     * Parse helper.
+     *
+     * @param positive  true if positive sign parsed, false for negative sign
+     * @param strict  true if strict, false if lenient
+     * @param fixedWidth  true if fixed width, false if not
+     * @return true if valid
+     */
+    parse(positive, strict, fixedWidth){
+        switch (this) {
+            case SignStyle.NORMAL: // NORMAL
+                // valid if negative or (positive and lenient)
+                return !positive || !strict;
+            case SignStyle.ALWAYS: // ALWAYS
+            case SignStyle.EXCEEDS_PAD: // EXCEEDS_PAD
+                return true;
+            default:
+                // valid if lenient and not fixed width
+                return !strict && !fixedWidth;
+        }
+
+    }
+}
+
+SignStyle.NORMAL = new SignStyle('NORMAL');
+SignStyle.NEVER = new SignStyle('NEVER');
+SignStyle.ALWAYS = new SignStyle('ALWAYS');
+SignStyle.EXCEEDS_PAD = new SignStyle('EXCEEDS_PAD');
+SignStyle.NOT_NEGATIVE = new SignStyle('NOT_NEGATIVE');

package/node_modules/@js-joda/core/src/format/StringBuilder.js

@@ -0,0 +1,47 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+/**
+ * @private
+ */
+export class StringBuilder {
+    constructor(){
+        this._str = '';
+    }
+
+    append(str){
+        this._str += str;
+        return this;
+    }
+
+    appendChar(str){
+        this._str += str[0];
+        return this;
+    }
+
+    insert(offset, str){
+        this._str = this._str.slice(0, offset) + str + this._str.slice(offset);
+        return this;
+    }
+
+    replace(start, end, str){
+        this._str = this._str.slice(0, start) + str + this._str.slice(end);
+        return this;
+    }
+
+    length(){
+        return this._str.length;
+    }
+
+    setLength(length){
+        this._str = this._str.slice(0, length);
+        return this;
+    }
+
+
+    toString() {
+        return this._str;
+    }
+}

package/node_modules/@js-joda/core/src/format/TextStyle.js

@@ -0,0 +1,114 @@
+/*
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @license BSD-3-Clause (see LICENSE.md in the root directory of this source tree)
+ */
+
+import {Enum} from '../Enum';
+
+/**
+ * Enumeration of the style of text formatting and parsing.
+ *
+ * Text styles define three sizes for the formatted text - 'full', 'short' and 'narrow'.
+ * Each of these three sizes is available in both 'standard' and 'stand-alone' variations.
+ *
+ * The difference between the three sizes is obvious in most languages.
+ * For example, in English the 'full' month is 'January', the 'short' month is 'Jan'
+ * and the 'narrow' month is 'J'. Note that the narrow size is often not unique.
+ * For example, 'January', 'June' and 'July' all have the 'narrow' text 'J'.
+ *
+ * The difference between the 'standard' and 'stand-alone' forms is trickier to describe
+ * as there is no difference in English. However, in other languages there is a difference
+ * in the word used when the text is used alone, as opposed to in a complete date.
+ * For example, the word used for a month when used alone in a date picker is different
+ * to the word used for month in association with a day and year in a date.
+ *
+ * ### Specification for implementors
+ *
+ * This is immutable and thread-safe enum.
+ */
+export class TextStyle extends Enum {
+    /**
+     * Checks if the style is stand-alone.
+     *
+     * @return {boolean} true if the style is stand-alone
+     */
+    isStandalone() {
+        switch (this) {
+            case TextStyle.FULL_STANDALONE:
+            case TextStyle.SHORT_STANDALONE:
+            case TextStyle.NARROW_STANDALONE:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Converts the style to the equivalent stand-alone style.
+     *
+     * @return {TextStyle} the matching stand-alone style
+     */
+    asStandalone() {
+        switch (this) {
+            case TextStyle.FULL:
+                return TextStyle.FULL_STANDALONE;
+            case TextStyle.SHORT:
+                return TextStyle.SHORT_STANDALONE;
+            case TextStyle.NARROW:
+                return TextStyle.NARROW_STANDALONE;
+            default:
+                // all others are already standalone
+                return this;
+        }
+    }
+
+    /**
+     * Converts the style to the equivalent normal style.
+     *
+     * @return {TextStyle} the matching normal style
+     */
+    asNormal() {
+        switch (this) {
+            case TextStyle.FULL_STANDALONE:
+                return TextStyle.FULL;
+            case TextStyle.SHORT_STANDALONE:
+                return TextStyle.SHORT;
+            case TextStyle.NARROW_STANDALONE:
+                return TextStyle.NARROW;
+            default:
+                // all others are already normal
+                return this;
+        }
+    }
+}
+
+/**
+ * Full text, typically the full description.
+ * For example, day-of-week Monday might output "Monday".
+ */
+TextStyle.FULL = new TextStyle('FULL');
+/**
+ * Full text for stand-alone use, typically the full description.
+ * For example, day-of-week Monday might output "Monday".
+ */
+TextStyle.FULL_STANDALONE = new TextStyle('FULL_STANDALONE');
+/**
+ * Short text, typically an abbreviation.
+ * For example, day-of-week Monday might output "Mon".
+ */
+TextStyle.SHORT = new TextStyle('SHORT');
+/**
+ * Short text for stand-alone use, typically an abbreviation.
+ * For example, day-of-week Monday might output "Mon".
+ */
+TextStyle.SHORT_STANDALONE = new TextStyle('SHORT_STANDALONE');
+/**
+ * Narrow text, typically a single letter.
+ * For example, day-of-week Monday might output "M".
+ */
+TextStyle.NARROW = new TextStyle('NARROW');
+/**
+ * Narrow text for stand-alone use, typically a single letter.
+ * For example, day-of-week Monday might output "M".
+ */
+TextStyle.NARROW_STANDALONE = new TextStyle('NARROW_STANDALONE');

package/node_modules/@js-joda/core/src/format/parser/CharLiteralPrinterParser.js

@@ -0,0 +1,46 @@
+/**
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {IllegalArgumentException} from '../../errors';
+
+/**
+ * Prints or parses a char literal.
+ * @private
+ */
+export class CharLiteralPrinterParser {
+
+    constructor(literal) {
+        if (literal.length > 1) {
+            throw new IllegalArgumentException('invalid literal, too long: "' + literal + '"');
+        }
+        this._literal = literal;
+    }
+
+    print(context, buf) {
+        buf.append(this._literal);
+        return true;
+    }
+
+    parse(context, text, position) {
+        const length = text.length;
+        if (position === length) {
+            return ~position;
+        }
+        const ch = text.charAt(position);
+        if (context.charEquals(this._literal, ch) === false) {
+            return ~position;
+        }
+        return position + this._literal.length;
+    }
+
+    toString() {
+        if (this._literal === '\'') {
+            return "''";
+        }
+        return "'" + this._literal + "'";
+    }
+}
+

package/node_modules/@js-joda/core/src/format/parser/CompositePrinterParser.js

@@ -0,0 +1,89 @@
+/**
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+/**
+ * @private
+ */
+export class CompositePrinterParser {
+
+    constructor(printerParsers, optional) {
+        this._printerParsers = printerParsers;
+        this._optional = optional;
+    }
+
+    /**
+     * Returns a copy of this printer-parser with the optional flag changed.
+     *
+     * @param {boolean} optional  the optional flag to set in the copy
+     * @return {CompositePrinterParser} the new printer-parser, not null
+     */
+    withOptional(optional) {
+        if (optional === this._optional) {
+            return this;
+        }
+        return new CompositePrinterParser(this._printerParsers, optional);
+    }
+
+    print(context, buf) {
+        const length = buf.length();
+        if (this._optional) {
+            context.startOptional();
+        }
+        try {
+            for (let i=0; i<this._printerParsers.length; i++) {
+                const pp = this._printerParsers[i];
+                if (pp.print(context, buf) === false) {
+                    buf.setLength(length);  // reset buffer
+                    return true;
+                }
+            }
+        } finally {
+            if (this._optional) {
+                context.endOptional();
+            }
+        }
+        return true;
+    }
+
+    parse(context, text, position) {
+        if (this._optional) {
+            context.startOptional();
+            let pos = position;
+            for (let i=0; i<this._printerParsers.length; i++) {
+                const pp = this._printerParsers[i];
+                pos = pp.parse(context, text, pos);
+                if (pos < 0) {
+                    context.endOptional(false);
+                    return position;  // return original position
+                }
+            }
+            context.endOptional(true);
+            return pos;
+        } else {
+            for (let i=0; i<this._printerParsers.length; i++) {
+                const pp = this._printerParsers[i];
+                position = pp.parse(context, text, position);
+                if (position < 0) {
+                    break;
+                }
+            }
+            return position;
+        }
+    }
+
+    toString() {
+        let buf = '';
+        if (this._printerParsers != null) {
+            buf += this._optional ? '[' : '(';
+            for (let i=0; i<this._printerParsers.length; i++) {
+                const pp = this._printerParsers[i];
+                buf += pp.toString();
+            }
+            buf += this._optional ? ']' : ')';
+        }
+        return buf;
+    }
+}

package/node_modules/@js-joda/core/src/format/parser/FractionPrinterParser.js

@@ -0,0 +1,162 @@
+/**
+ * @copyright (c) 2016, Philipp Thürwächter & Pattrick Hüper
+ * @copyright (c) 2007-present, Stephen Colebourne & Michael Nascimento Santos
+ * @license BSD-3-Clause (see LICENSE in the root directory of this source tree)
+ */
+
+import {requireNonNull} from '../../assert';
+import {IllegalArgumentException} from '../../errors';
+import {MathUtil} from '../../MathUtil';
+
+/**
+ * TODO optimize FractionPrinterParser, fix documentation
+ *
+ * Prints and parses a numeric date-time field with optional padding.
+ * @private
+ */
+export class FractionPrinterParser {
+
+    /**
+     * Constructor.
+     *
+     * @param {TemporalField} field  the field to output, not null
+     * @param {Number} minWidth  the minimum width to output, from 0 to 9
+     * @param {Number} maxWidth  the maximum width to output, from 0 to 9
+     * @param {boolean} decimalPoint  whether to output the localized decimal point symbol
+     */
+    constructor(field, minWidth, maxWidth, decimalPoint) {
+        requireNonNull(field, 'field');
+        if (field.range().isFixed() === false) {
+            throw new IllegalArgumentException('Field must have a fixed set of values: ' + field);
+        }
+        if (minWidth < 0 || minWidth > 9) {
+            throw new IllegalArgumentException('Minimum width must be from 0 to 9 inclusive but was ' + minWidth);
+        }
+        if (maxWidth < 1 || maxWidth > 9) {
+            throw new IllegalArgumentException('Maximum width must be from 1 to 9 inclusive but was ' + maxWidth);
+        }
+        if (maxWidth < minWidth) {
+            throw new IllegalArgumentException('Maximum width must exceed or equal the minimum width but ' +
+                maxWidth + ' < ' + minWidth);
+        }
+        this.field = field;
+        this.minWidth = minWidth;
+        this.maxWidth = maxWidth;
+        this.decimalPoint = decimalPoint;
+    }
+
+    print(context, buf) {
+        const value = context.getValue(this.field);
+        if (value === null) {
+            return false;
+        }
+        const symbols = context.symbols();
+        if (value === 0) {  // scale is zero if value is zero
+            if (this.minWidth > 0) {
+                if (this.decimalPoint) {
+                    buf.append(symbols.decimalSeparator());
+                }
+                for (let i = 0; i < this.minWidth; i++) {
+                    buf.append(symbols.zeroDigit());
+                }
+            }
+        } else {
+            let fraction = this.convertToFraction(value, symbols.zeroDigit());
+            const outputScale = Math.min(Math.max(fraction.length, this.minWidth), this.maxWidth);
+            fraction = fraction.substr(0, outputScale);
+            if(fraction * 1 > 0 ) {
+                while (fraction.length > this.minWidth && fraction[fraction.length - 1] === '0') {
+                    fraction = fraction.substr(0, fraction.length - 1);
+                }
+            }
+            let str = fraction;
+            str = symbols.convertNumberToI18N(str);
+            if (this.decimalPoint) {
+                buf.append(symbols.decimalSeparator());
+            }
+            buf.append(str);
+        }
+        return true;
+    }
+
+    parse(context, text, position) {
+        const effectiveMin = (context.isStrict() ? this.minWidth : 0);
+        const effectiveMax = (context.isStrict() ? this.maxWidth : 9);
+        const length = text.length;
+        if (position === length) {
+            // valid if whole field is optional, invalid if minimum width
+            return (effectiveMin > 0 ? ~position : position);
+        }
+        if (this.decimalPoint) {
+            if (text[position] !== context.symbols().decimalSeparator()) {
+                // valid if whole field is optional, invalid if minimum width
+                return (effectiveMin > 0 ? ~position : position);
+            }
+            position++;
+        }
+        const minEndPos = position + effectiveMin;
+        if (minEndPos > length) {
+            return ~position;  // need at least min width digits
+        }
+        const maxEndPos = Math.min(position + effectiveMax, length);
+        let total = 0;  // can use int because we are only parsing up to 9 digits
+        let pos = position;
+        while (pos < maxEndPos) {
+            const ch = text.charAt(pos++);
+            const digit = context.symbols().convertToDigit(ch);
+            if (digit < 0) {
+                if (pos < minEndPos) {
+                    return ~position;  // need at least min width digits
+                }
+                pos--;
+                break;
+            }
+            total = total * 10 + digit;
+        }
+        const moveLeft = pos - position;
+        const scale = Math.pow(10, moveLeft);
+        const value = this.convertFromFraction(total, scale);
+        return context.setParsedField(this.field, value, position, pos);
+    }
+
+    /**
+     *
+     * @param {Number} value  the value to convert, must be valid for this rule
+     * @param {String} zeroDigit  the character for zero
+     * @return {String} the value as a fraction within the range, from 0 to 1, not null
+     */
+    convertToFraction(value, zeroDigit) {
+        const range = this.field.range();
+        range.checkValidValue(value, this.field);
+        const _min = range.minimum();
+        const _range = range.maximum() - _min + 1;
+        const _value = value - _min;
+        const _scaled = MathUtil.intDiv((_value * 1000000000),  _range);
+        let fraction = '' + _scaled;
+        while(fraction.length < 9){
+            fraction = zeroDigit + fraction;
+        }
+        return fraction;
+    }
+
+    /**
+     *
+     * @param {Number} total  the fraction to convert, not null
+     * @param {Number} scale  the scale, not null
+     * @return {Number} the value of the field, valid for this rule
+     * @throws DateTimeException if the value cannot be converted
+     */
+    convertFromFraction(total, scale) {
+        const range = this.field.range();
+        const _min = range.minimum();
+        const _range = range.maximum() - _min + 1;
+        const _value = MathUtil.intDiv((total * _range), scale);
+        return _value;
+    }
+
+    toString() {
+        const decimal = (this.decimalPoint ? ',DecimalPoint' : '');
+        return 'Fraction(' + this.field + ',' + this.minWidth + ',' + this.maxWidth + decimal + ')';
+    }
+}
+