@attocash/cli 0.1.0

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

@@ -0,0 +1,297 @@
+/*
+ * @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 {assert, requireNonNull} from '../assert';
+
+import {DateTimeBuilder} from './DateTimeBuilder';
+import {EnumMap} from './EnumMap';
+
+import {IsoChronology} from '../chrono/IsoChronology';
+import {Temporal} from '../temporal/Temporal';
+import {TemporalQueries} from '../temporal/TemporalQueries';
+
+/**
+ * @private
+ */
+export class DateTimeParseContext{
+
+    constructor(){
+        if(arguments.length === 1){
+            if(arguments[0] instanceof DateTimeParseContext){
+                this._constructorSelf.apply(this, arguments);
+                return;
+            } else {
+                this._constructorFormatter.apply(this, arguments);
+            }
+        } else {
+            this._constructorParam.apply(this, arguments);
+        }
+
+        this._caseSensitive = true;
+        this._strict = true;
+        this._parsed = [new Parsed(this)];
+    }
+
+    _constructorParam(locale, symbols, chronology){
+        this._locale = locale;
+        this._symbols = symbols;
+        this._overrideChronology = chronology;
+    }
+
+    _constructorFormatter(formatter){
+        this._locale = formatter.locale();
+        this._symbols = formatter.decimalStyle();
+        this._overrideChronology = formatter.chronology();
+    }
+
+
+    _constructorSelf(other) {
+        this._locale = other._locale;
+        this._symbols = other._symbols;
+        this._overrideChronology = other._overrideChronology;
+        this._overrideZone = other._overrideZone;
+        this._caseSensitive = other._caseSensitive;
+        this._strict = other._strict;
+        this._parsed = [new Parsed(this)];
+    }
+
+    /**
+     * Creates a copy of this context.
+     */
+    copy() {
+        return new DateTimeParseContext(this);
+    }
+
+    symbols(){
+        return this._symbols;
+    }
+
+    isStrict(){
+        return this._strict;
+    }
+
+    setStrict(strict){
+        this._strict = strict;
+    }
+
+    locale() {
+        return this._locale;
+    }
+
+    setLocale(locale) {
+        this._locale = locale;
+    }
+    //-----------------------------------------------------------------------
+    /**
+     * Starts the parsing of an optional segment of the input.
+     */
+    startOptional() {
+        this._parsed.push(this.currentParsed().copy());
+    }
+
+    /**
+     * Ends the parsing of an optional segment of the input.
+     *
+     * @param {boolean} successful  whether the optional segment was successfully parsed
+     */
+    endOptional(successful) {
+        if (successful) {
+            this._parsed.splice(this._parsed.length - 2, 1);
+        } else {
+            this._parsed.splice(this._parsed.length - 1, 1);
+        }
+    }
+
+    /**
+     * Checks if parsing is case sensitive.
+     *
+     * @return true if parsing is case sensitive, false if case insensitive
+     */
+    isCaseSensitive() {
+        return this._caseSensitive;
+    }
+
+    /**
+     * Sets whether the parsing is case sensitive or not.
+     *
+     * @param caseSensitive  changes the parsing to be case sensitive or not from now on
+     */
+    setCaseSensitive(caseSensitive) {
+        this._caseSensitive = caseSensitive;
+    }
+
+    /**
+     * Helper to compare two {@link CharSequence} instances.
+     * This uses {@link isCaseSensitive}.
+     *
+     * @param cs1  the first character sequence, not null
+     * @param offset1  the offset into the first sequence, valid
+     * @param cs2  the second character sequence, not null
+     * @param offset2  the offset into the second sequence, valid
+     * @param length  the length to check, valid
+     * @return true if equal
+     */
+    subSequenceEquals(cs1, offset1, cs2, offset2, length) {
+        if (offset1 + length > cs1.length || offset2 + length > cs2.length) {
+            return false;
+        }
+        if (! this.isCaseSensitive()) {
+            cs1 = cs1.toLowerCase();
+            cs2 = cs2.toLowerCase();
+        }
+        for (let i = 0; i < length; i++) {
+            const ch1 = cs1[offset1 + i];
+            const ch2 = cs2[offset2 + i];
+            if (ch1 !== ch2) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Helper to compare two `char`.
+     * This uses {@link isCaseSensitive}.
+     *
+     * @param ch1  the first character
+     * @param ch2  the second character
+     * @return true if equal
+     */
+    charEquals(ch1, ch2) {
+        if (this.isCaseSensitive()) {
+            return ch1 === ch2;
+        }
+        return this.charEqualsIgnoreCase(ch1, ch2);
+    }
+
+    /**
+     * Compares two characters ignoring case.
+     *
+     * @param c1  the first
+     * @param c2  the second
+     * @return true if equal
+     */
+    charEqualsIgnoreCase(c1, c2) {
+        return c1 === c2 ||
+                c1.toLowerCase() === c2.toLowerCase();
+    }
+
+    setParsedField(field, value, errorPos, successPos){
+        const currentParsedFieldValues = this.currentParsed().fieldValues;
+        const old = currentParsedFieldValues.get(field);
+        currentParsedFieldValues.set(field, value);
+        return (old != null && old !== value) ? ~errorPos : successPos;
+    }
+
+    /**
+     * Stores the parsed zone.
+     *
+     * This stores the zone that has been parsed.
+     * No validation is performed other than ensuring it is not null.
+     *
+     * @param {ZoneId} zone  the parsed zone, not null
+     */
+    setParsedZone(zone) {
+        requireNonNull(zone, 'zone');
+        this.currentParsed().zone = zone;
+    }
+
+    getParsed(field) {
+        return this.currentParsed().fieldValues.get(field);
+    }
+
+    toParsed() {
+        return this.currentParsed();
+    }
+
+    currentParsed() {
+        return this._parsed[this._parsed.length - 1];
+    }
+
+    /**
+     * Stores the leap second.
+     */
+    setParsedLeapSecond() {
+        this.currentParsed().leapSecond = true;
+    }
+
+    /**
+     * Gets the effective chronology during parsing.
+     *
+     * @return the effective parsing chronology, not null
+     */
+    getEffectiveChronology() {
+        let chrono = this.currentParsed().chrono;
+        if (chrono == null) {
+            chrono = this._overrideChronology;
+            if (chrono == null) {
+                chrono = IsoChronology.INSTANCE;
+            }
+        }
+        return chrono;
+    }
+
+
+}
+
+class Parsed extends Temporal {
+    constructor(dateTimeParseContext){
+        super();
+        this.chrono = null;
+        this.zone = null;
+        this.fieldValues = new EnumMap();
+        this.leapSecond = false;
+        this.dateTimeParseContext = dateTimeParseContext;
+    }
+
+    copy() {
+        const cloned = new Parsed();
+        cloned.chrono = this.chrono;
+        cloned.zone = this.zone;
+        cloned.fieldValues.putAll(this.fieldValues);
+        cloned.leapSecond = this.leapSecond;
+        cloned.dateTimeParseContext = this.dateTimeParseContext;
+        return cloned;
+    }
+
+    toString() {
+        return `${this.fieldValues}, ${this.chrono}, ${this.zone}`;
+    }
+
+    isSupported(field) {
+        return this.fieldValues.containsKey(field);
+    }
+
+    get(field) {
+        const val = this.fieldValues.get(field);
+        assert(val != null);
+        return val;
+    }
+
+    query(query) {
+        if (query === TemporalQueries.chronology()) {
+            return this.chrono;
+        }
+        if (query === TemporalQueries.zoneId() || query === TemporalQueries.zone()) {
+            return this.zone;
+        }
+        return super.query(query);
+    }
+
+    toBuilder() {
+        const builder = new DateTimeBuilder();
+        builder.fieldValues.putAll(this.fieldValues);
+        builder.chrono = this.dateTimeParseContext.getEffectiveChronology();
+        if (this.zone != null) {
+            builder.zone = this.zone;
+        } else {
+            builder.zone = this.overrideZone;
+        }
+        builder.leapSecond = this.leapSecond;
+        builder.excessDays = this.excessDays;
+        return builder;
+    }
+}

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

@@ -0,0 +1,138 @@
+/*
+ * @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 {DateTimeException} from '../errors';
+
+import {DateTimeFormatter} from './DateTimeFormatter';
+
+/**
+ * @private
+ */
+export class DateTimePrintContext{
+    /**
+     *
+     * @param {TemporalAccessor} temporal
+     * @param {DateTimeFormatter|Locale} localeOrFormatter
+     * @param {DecimalStyle} symbols
+     */
+    constructor(temporal, localeOrFormatter, symbols) {
+        if(arguments.length === 2 && arguments[1] instanceof DateTimeFormatter){
+            this._temporal = DateTimePrintContext.adjust(temporal, localeOrFormatter);
+            this._locale = localeOrFormatter.locale();
+            this._symbols = localeOrFormatter.decimalStyle();
+        } else {
+            this._temporal = temporal;
+            this._locale = localeOrFormatter;
+            this._symbols = symbols;
+        }
+        this._optional = 0;
+    }
+
+    /**
+     *
+     * @param {TemporalAccessor} temporal
+     * @param {DateTimeFormatter} formatter
+     * @returns {TemporalAccessor}
+     */
+    // eslint-disable-next-line no-unused-vars
+    static adjust(temporal, formatter) {
+        // TODO implement
+        return temporal;
+    }
+
+
+    symbols(){
+        return this._symbols;
+    }
+
+    /**
+     * Starts the printing of an optional segment of the input.
+     */
+    startOptional() {
+        this._optional++;
+    }
+
+    /**
+     * Ends the printing of an optional segment of the input.
+     */
+    endOptional() {
+        this._optional--;
+    }
+
+    /**
+     * Gets a value using a query.
+     *
+     * @param {TemporalQuery} query  the query to use, not null
+     * @return {*} the result, null if not found and optional is true
+     * @throws DateTimeException if the type is not available and the section is not optional
+     */
+    getValueQuery(query) {
+        const result = this._temporal.query(query);
+        if (result == null && this._optional === 0) {
+            throw new DateTimeException('Unable to extract value: ' + this._temporal);
+        }
+        return result;
+    }
+
+    /**
+     * Gets the value of the specified field.
+     *
+     * This will return the value for the specified field.
+     *
+     * @param field  the field to find, not null
+     * @return the value, null if not found and optional is true
+     * @throws DateTimeException if the field is not available and the section is not optional
+     */
+    getValue(field) {
+        try {
+            return this._temporal.getLong(field);
+        } catch (ex) {
+            if ((ex instanceof DateTimeException) && this._optional > 0) {
+                return null;
+            }
+            throw ex;
+        }
+    }
+
+    //-----------------------------------------------------------------------
+    /**
+     * Gets the temporal object being output.
+     *
+     * @return {TemporalAccessor} the temporal object, not null
+     */
+    temporal() {
+        return this._temporal;
+    }
+
+    /**
+     * Gets the locale.
+     * <p>
+     * This locale is used to control localization in the print output except
+     * where localization is controlled by the symbols.
+     *
+     * @return the locale, not null
+     */
+    locale() {
+        return this._locale;
+    }
+
+    //-------------------------------------------------------------------------
+    // for testing
+    /**
+     * Sets the date-time being output.
+     *
+     * @param temporal  the date-time object, not null
+     */
+    setDateTime(temporal) {
+        this._temporal = temporal;
+    }
+
+    setLocale(locale) {
+        this._locale = locale;
+    }
+
+
+}

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

@@ -0,0 +1,113 @@
+/**
+ * @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)
+ */
+
+export class DecimalStyle {
+    /**
+     *
+     * @param zeroChar
+     * @param positiveSignChar
+     * @param negativeSignChar
+     * @param decimalPointChar
+     * @private
+     */
+    constructor(zeroChar, positiveSignChar, negativeSignChar, decimalPointChar) {
+        this._zeroDigit = zeroChar;
+        this._zeroDigitCharCode = zeroChar.charCodeAt(0);
+        this._positiveSign = positiveSignChar;
+        this._negativeSign = negativeSignChar;
+        this._decimalSeparator = decimalPointChar;
+    }
+
+    positiveSign(){
+        return this._positiveSign;
+    }
+
+    withPositiveSign(positiveSign) {
+        if (positiveSign === this._positiveSign) {
+            return this;
+        }
+        return new DecimalStyle(this._zeroDigit, positiveSign, this._negativeSign, this._decimalSeparator);
+    }
+
+    negativeSign(){
+        return this._negativeSign;
+    }
+
+    withNegativeSign(negativeSign) {
+        if (negativeSign === this._negativeSign) {
+            return this;
+        }
+        return new DecimalStyle(this._zeroDigit, this._positiveSign, negativeSign, this._decimalSeparator);
+    }
+
+    zeroDigit(){
+        return this._zeroDigit;
+    }
+
+    withZeroDigit(zeroDigit) {
+        if (zeroDigit === this._zeroDigit) {
+            return this;
+        }
+        return new DecimalStyle(zeroDigit, this._positiveSign, this._negativeSign, this._decimalSeparator);
+    }
+
+    decimalSeparator(){
+        return this._decimalSeparator;
+    }
+
+    withDecimalSeparator(decimalSeparator) {
+        if (decimalSeparator === this._decimalSeparator) {
+            return this;
+        }
+        return new DecimalStyle(this._zeroDigit, this._positiveSign, this._negativeSign, decimalSeparator);
+    }
+
+    convertToDigit(char){
+        const val = char.charCodeAt(0) - this._zeroDigitCharCode;
+        return (val >= 0 && val <= 9) ? val : -1;
+    }
+
+    convertNumberToI18N(numericText) {
+        if (this._zeroDigit === '0') {
+            return numericText;
+        }
+        const diff = this._zeroDigitCharCode - '0'.charCodeAt(0);
+        let convertedText = '';
+        for (let i = 0; i < numericText.length; i++) {
+            convertedText += String.fromCharCode(numericText.charCodeAt(i) + diff);
+        }
+        return convertedText;
+    }
+
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+        if (other instanceof DecimalStyle) {
+            return (this._zeroDigit === other._zeroDigit && this._positiveSign === other._positiveSign &&
+                this._negativeSign === other._negativeSign && this._decimalSeparator === other._decimalSeparator);
+        }
+        return false;
+    }
+
+    hashCode() {
+        return this._zeroDigit + this._positiveSign + this._negativeSign + this._decimalSeparator;
+    }
+
+    toString() {
+        return 'DecimalStyle[' + this._zeroDigit + this._positiveSign + this._negativeSign + this._decimalSeparator + ']';
+    }
+
+    static of(){
+        throw new Error('not yet supported');
+    }
+    static availableLocales(){
+        throw new Error('not yet supported');
+    }
+
+}
+
+DecimalStyle.STANDARD = new DecimalStyle('0', '+', '-', '.');

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

@@ -0,0 +1,70 @@
+/*
+ * @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 EnumMap {
+    constructor(){
+        this._map = {};
+    }
+
+    putAll(otherMap){
+        for(const key in otherMap._map){
+            this._map[key] = otherMap._map[key];
+        }
+        return this;
+    }
+
+    containsKey(key){
+        // eslint-disable-next-line no-prototype-builtins
+        return (this._map.hasOwnProperty(key.name())) && (this.get(key) !== undefined);
+    }
+
+    get(key) {
+        return this._map[key.name()];
+    }
+
+    put(key, val) {
+        return this.set(key, val);
+    }
+
+    set(key, val) {
+        this._map[key.name()] = val;
+        return this;
+    }
+
+    retainAll(keyList){
+        const map = {};
+        for(let i=0; i<keyList.length; i++){
+            const key = keyList[i].name();
+            map[key] = this._map[key];
+        }
+        this._map = map;
+        return this;
+    }
+
+    /**
+     * due to the bad performance of delete we just set the key entry to undefined.
+     *
+     * this might lead to issues with "null" entries. Calling clear in the end might solve the issue
+     * @param key
+     * @returns {*}
+     */
+    remove(key){
+        const keyName = key.name();
+        const val = this._map[keyName];
+        this._map[keyName] = undefined;
+        return val;
+    }
+
+    keySet(){
+        return this._map;
+    }
+
+    clear(){
+        this._map = {};
+    }
+}

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

@@ -0,0 +1,31 @@
+/*
+ * @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 ParsePosition {
+    constructor(index) {
+        this._index = index;
+        this._errorIndex = -1;
+    }
+
+    getIndex(){
+        return this._index;
+    }
+
+    setIndex(index){
+        this._index = index;
+    }
+
+    getErrorIndex(){
+        return this._errorIndex;
+    }
+
+    setErrorIndex(errorIndex){
+        this._errorIndex = errorIndex;
+    }
+}