chrono-node 1.3.5 → 1.4.4

package/src/parsers/pt/PTDeadlineFormatParser.js

@@ -0,0 +1,61 @@
+const dayjs = require('dayjs');
+var Parser = require('../parser').Parser;
+var ParsedResult = require('../../result').ParsedResult;
+
+var PATTERN = /(\W|^)(dentro\s*de|em|em*até)\s*([0-9]+|mei[oa]|uma?)\s*(minutos?|horas?|dias?)\s*(?=(?:\W|$))/i;
+
+exports.Parser = function PTDeadlineFormatParser(){
+    Parser.apply(this, arguments);
+
+    this.pattern = function() { return PATTERN; }
+
+    this.extract = function(text, ref, match, opt){
+
+        var index = match.index + match[1].length;
+        var text  = match[0];
+        text  = match[0].substr(match[1].length, match[0].length - match[1].length);
+
+        var result = new ParsedResult({
+            index: index,
+            text: text,
+            ref: ref,
+        });
+
+        var num = parseInt(match[3]);
+        if (isNaN(num)) {
+          if (match[3].match(/(meio|meia)/)) {
+            num = 0.5;
+          } else {
+            num = 1;
+          }
+        }
+
+        var date = dayjs(ref);
+        if (match[4].match(/dia/)) {
+            date = date.add(num, 'd');
+
+            result.start.assign('year', date.year());
+            result.start.assign('month', date.month() + 1);
+            result.start.assign('day', date.date());
+            return result;
+        }
+
+
+        if (match[4].match(/hora/)) {
+
+            date = date.add(num, 'hour');
+
+        } else if (match[4].match(/minuto/)) {
+
+            date = date.add(num, 'minute');
+        }
+
+        result.start.imply('year', date.year());
+        result.start.imply('month', date.month() + 1);
+        result.start.imply('day', date.date());
+        result.start.assign('hour', date.hour());
+        result.start.assign('minute', date.minute());
+        result.tags['PTDeadlineFormatParser'] = true;
+        return result;
+    };
+}

package/src/parsers/pt/PTMonthNameLittleEndianParser.js

@@ -0,0 +1,86 @@
+var parser = require('../parser');
+var ParsedResult = require('../../result').ParsedResult;
+
+var util  = require('../../utils/PT');
+
+var DAYS_OFFSET = util.WEEKDAY_OFFSET;
+
+var PATTERN = new RegExp('(\\W|^)' +
+        '(?:(domingo|segunda|segunda-feira|terça|terça-feira|quarta|quarta-feira|quinta|quinta-feira|sexta|sexta-feira|sábado|sabado|dom|seg|ter|qua|qui|sex|sab)\\s*,?\\s*)?' +
+        '([0-9]{1,2})(?:º|ª|°)?' +
+        '(?:\\s*(?:desde|de|\\-|\\–|ao?|\\s)\\s*([0-9]{1,2})(?:º|ª|°)?)?\\s*(?:de)?\\s*' +
+        '(Jan(?:eiro|\\.)?|Fev(?:ereiro|\\.)?|Mar(?:ço|\\.)?|Abr(?:il|\\.)?|Mai(?:o|\\.)?|Jun(?:ho|\\.)?|Jul(?:ho|\\.)?|Ago(?:sto|\\.)?|Set(?:embro|\\.)?|Out(?:ubro|\\.)?|Nov(?:embro|\\.)?|Dez(?:embro|\\.)?)' +
+        '(?:\\s*(?:de?)?(\\s*[0-9]{1,4}(?![^\\s]\\d))(\\s*[ad]\\.?\\s*c\\.?|a\\.?\\s*d\\.?)?)?' +
+        '(?=\\W|$)', 'i'
+    );
+
+var WEEKDAY_GROUP = 2;
+var DATE_GROUP = 3;
+var DATE_TO_GROUP = 4;
+var MONTH_NAME_GROUP = 5;
+var YEAR_GROUP = 6;
+var YEAR_BE_GROUP = 7;
+
+exports.Parser = function PTMonthNameLittleEndianParser(){
+    parser.Parser.apply(this, arguments);
+
+    this.pattern = function() { return PATTERN; }
+
+    this.extract = function(text, ref, match, opt){
+
+        var result = new ParsedResult({
+            text: match[0].substr(match[1].length, match[0].length - match[1].length),
+            index: match.index + match[1].length,
+            ref: ref,
+        });
+
+        var month = match[MONTH_NAME_GROUP];
+        month = util.MONTH_OFFSET[month.toLowerCase()];
+
+        var day = match[DATE_GROUP];
+        day = parseInt(day);
+
+        var year = null;
+        if (match[YEAR_GROUP]) {
+            year = match[YEAR_GROUP];
+            year = parseInt(year);
+
+            if(match[YEAR_BE_GROUP]){
+                if (/a\.?\s*c\.?/i.test(match[YEAR_BE_GROUP])) {
+                    // antes de Cristo
+                    year = -year;
+                }
+            } else if (year < 100){
+
+                year = year + 2000;
+            }
+        }
+
+        if(year){
+            result.start.assign('day', day);
+            result.start.assign('month', month);
+            result.start.assign('year', year);
+        } else {
+            year = parser.findYearClosestToRef(ref, day, month);
+            result.start.assign('day', day);
+            result.start.assign('month', month);
+            result.start.imply('year', year);
+        }
+
+        // Weekday component
+        if (match[WEEKDAY_GROUP]) {
+            var weekday = match[WEEKDAY_GROUP];
+            weekday = util.WEEKDAY_OFFSET[weekday.toLowerCase()]
+            result.start.assign('weekday', weekday);
+        }
+
+        // Text can be 'range' value. Such as '12 - 13 January 2012'
+        if (match[DATE_TO_GROUP]) {
+            result.end = result.start.clone();
+            result.end.assign('day', parseInt(match[DATE_TO_GROUP]));
+        }
+
+        result.tags['PTMonthNameLittleEndianParser'] = true;
+        return result;
+    };
+}

package/src/parsers/pt/PTSlashDateFormatParser.js

@@ -0,0 +1,114 @@
+/*
+    Date format with slash "/" (also "-" and ".") between numbers
+    - Martes 3/11/2015
+    - 3/11/2015
+    - 3/11
+*/
+const dayjs = require('dayjs');
+var Parser = require('../parser').Parser;
+var ParsedResult = require('../../result').ParsedResult;
+
+var PATTERN = new RegExp('(\\W|^)' +
+    '(?:' +
+        '((?:domingo|dom|segunda|segunda-feira|seg|terça|terça-feira|ter|quarta|quarta-feira|qua|quinta|quinta-feira|qui|sexta|sexta-feira|sex|s[áa]bado|sab))' +
+        '\\s*\\,?\\s*' +
+    ')?' +
+    '([0-1]{0,1}[0-9]{1})[\\/\\.\\-]([0-3]{0,1}[0-9]{1})' +
+    '(?:' +
+        '[\\/\\.\\-]' +
+        '([0-9]{4}\s*\,?\s*|[0-9]{2}\s*\,?\s*)' +
+    ')?' +
+    '(\\W|$)', 'i');
+
+var DAYS_OFFSET = { 'domingo': 0, 'dom': 0, 'segunda': 1, 'segunda-feira': 1, 'seg': 1, 'terça': 2, 'terça-feira': 2, 'ter': 2, 'quarta': 3, 'quarta-feira': 3, 'qua': 3,
+    'quinta': 4, 'quinta-feira': 4, 'qui': 4, 'sexta': 5, 'sexta-feira': 5, 'sex': 5, 'sábado': 6, 'sabado': 6, 'sab': 6,}
+
+
+var OPENNING_GROUP = 1;
+var ENDING_GROUP = 6;
+
+// in Spanish we use day/month/year
+var WEEKDAY_GROUP = 2;
+var MONTH_GROUP = 4;
+var DAY_GROUP = 3;
+var YEAR_GROUP = 5;
+
+exports.Parser = function PTSlashDateFormatParser(argument) {
+    Parser.apply(this, arguments);
+
+    this.pattern = function () { return PATTERN; };
+    this.extract = function(text, ref, match, opt){
+
+        if(match[OPENNING_GROUP] == '/' || match[ENDING_GROUP] == '/') {
+            // Long skip, if there is some overlapping like:
+            // XX[/YY/ZZ]
+            // [XX/YY/]ZZ
+            match.index += match[0].length
+            return;
+        }
+
+        var index = match.index + match[OPENNING_GROUP].length;
+        var text = match[0].substr(match[OPENNING_GROUP].length, match[0].length - match[ENDING_GROUP].length);
+
+
+        var result = new ParsedResult({
+            text: text,
+            index: index,
+            ref: ref,
+        });
+
+        if(text.match(/^\d\.\d$/)) return;
+        if(text.match(/^\d\.\d{1,2}\.\d{1,2}$/)) return;
+
+        // MM/dd -> OK
+        // MM.dd -> NG
+        if(!match[YEAR_GROUP] && match[0].indexOf('/') < 0) return;
+
+        var date = null;
+        var year = match[YEAR_GROUP] || dayjs(ref).year() + '';
+        var month = match[MONTH_GROUP];
+        var day   = match[DAY_GROUP];
+
+        month = parseInt(month);
+        day  = parseInt(day);
+        year = parseInt(year);
+
+        if(month < 1 || month > 12) {
+            if(month > 12) {
+                // dd/mm/yyyy date format if day looks like a month, and month
+                // looks like a day.
+                if (day >= 1 && day <= 12 && month >= 13 && month <= 31) {
+                    // unambiguous
+                    var tday = month;
+                    month = day;
+                    day = tday;
+                }
+                else {
+                    // both month and day are <= 12
+                    return null;
+                }
+            }
+        }
+        if(day < 1 || day > 31) return null;
+
+        if(year < 100){
+            if(year > 50){
+                year = year + 1900;
+            }else{
+                year = year + 2000;
+            }
+        }
+
+        result.start.assign('day', day);
+        result.start.assign('month', month);
+        result.start.assign('year', year);
+
+        //Day of week
+        if(match[WEEKDAY_GROUP]) {
+            result.start.assign('weekday', DAYS_OFFSET[match[WEEKDAY_GROUP].toLowerCase()]);
+        }
+
+        result.tags['PTSlashDateFormatParser'] = true;
+        return result;
+    };
+};

package/src/parsers/pt/PTTimeAgoFormatParser.js

@@ -0,0 +1,87 @@
+const dayjs = require('dayjs');
+var Parser = require('../parser').Parser;
+var ParsedResult = require('../../result').ParsedResult;
+
+var PATTERN = /(\W|^)há\s*([0-9]+|mei[oa]|uma?)\s*(minutos?|horas?|semanas?|dias?|mes(es)?|anos?)(?=(?:\W|$))/i;
+
+exports.Parser = function PTTimeAgoFormatParser(){
+    Parser.apply(this, arguments);
+
+    this.pattern = function() {
+        return PATTERN;
+    }
+
+    this.extract = function(text, ref, match, opt){
+
+        if (match.index > 0 && text[match.index-1].match(/\w/)) return null;
+
+        var text = match[0];
+        text  = match[0].substr(match[1].length, match[0].length - match[1].length);
+        index = match.index + match[1].length;
+
+        var result = new ParsedResult({
+            index: index,
+            text: text,
+            ref: ref,
+        });
+
+        var num = parseInt(match[2]);
+        if (isNaN(num)) {
+          if (match[2].match(/mei/)) {
+            num = 0.5;
+          } else {
+            num = 1;
+          }
+        }
+
+        var date = dayjs(ref);
+
+        if (match[3].match(/hora/) || match[3].match(/minuto/)) {
+            if (match[3].match(/hora/)) {
+
+                date = date.add(-num, 'hour');
+
+            } else if (match[3].match(/minuto/)) {
+
+                date = date.add(-num, 'minute');
+            }
+
+            result.start.imply('day', date.date());
+            result.start.imply('month', date.month() + 1);
+            result.start.imply('year', date.year());
+            result.start.assign('hour', date.hour());
+            result.start.assign('minute', date.minute());
+            result.tags['PTTimeAgoFormatParser'] = true;
+            return result;
+        }
+
+        if (match[3].match(/semana/)) {
+            date = date.add(-num, 'week');
+
+            result.start.imply('day', date.date());
+            result.start.imply('month', date.month() + 1);
+            result.start.imply('year', date.year());
+            result.start.imply('weekday', date.day());
+            return result;
+        }
+
+        if (match[3].match(/dia/)) {
+            date = date.add(-num, 'd');
+        }
+
+        if (match[3].match(/mes/)) {
+            date = date.add(-num, 'month');
+        }
+
+        if (match[3].match(/ano/)) {
+
+            date = date.add(-num, 'year');
+        }
+
+        result.start.assign('day', date.date());
+        result.start.assign('month', date.month() + 1);
+        result.start.assign('year', date.year());
+        return result;
+
+    };
+}

package/src/parsers/pt/PTTimeExpressionParser.js

@@ -0,0 +1,234 @@
+const dayjs = require('dayjs');
+var Parser = require('../parser').Parser;
+var ParsedResult = require('../../result').ParsedResult;
+var ParsedComponents = require('../../result').ParsedComponents;
+
+var FIRST_REG_PATTERN  = new RegExp("(^|\\s|T)" +
+    "(?:(?:ao?|às?|das|da|do)\\s*)?" +
+    "(\\d{1,4}|meio-dia|meia-noite|meio dia|meia noite)" +
+    "(?:" +
+        "(?:\\.|\\:|\\：)(\\d{1,2})" +
+        "(?:" +
+            "(?:\\:|\\：)(\\d{2})" +
+        ")?" +
+    ")?" +
+    "(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?))?" +
+    "(?=\\W|$)", 'i');
+
+
+var SECOND_REG_PATTERN = new RegExp("^\\s*" +
+    "(\\-|\\–|\\~|\\〜|a(?:o)?|\\?)\\s*" +
+    "(\\d{1,4})" +
+    "(?:" +
+        "(?:\\.|\\:|\\：)(\\d{1,2})" +
+        "(?:" +
+            "(?:\\.|\\:|\\：)(\\d{1,2})" +
+        ")?" +
+    ")?" +
+    "(?:\\s*(A\\.M\\.|P\\.M\\.|AM?|PM?))?" +
+    "(?=\\W|$)", 'i');
+
+var HOUR_GROUP    = 2;
+var MINUTE_GROUP  = 3;
+var SECOND_GROUP  = 4;
+var AM_PM_HOUR_GROUP = 5;
+
+exports.Parser = function PTTimeExpressionParser(){
+    Parser.apply(this, arguments);
+
+    this.pattern = function() { return FIRST_REG_PATTERN; }
+
+    this.extract = function(text, ref, match, opt){
+
+        // This pattern can be overlaped Ex. [12] AM, 1[2] AM
+        if (match.index > 0 && text[match.index-1].match(/\w/)) return null;
+        var refMoment = dayjs(ref);
+        var result = new ParsedResult();
+        result.ref = ref;
+        result.index = match.index + match[1].length;
+        result.text  = match[0].substring(match[1].length);
+        result.tags['PTTimeExpressionParser'] = true;
+
+        result.start.imply('day',   refMoment.date());
+        result.start.imply('month', refMoment.month()+1);
+        result.start.imply('year',  refMoment.year());
+
+        var hour = 0;
+        var minute = 0;
+        var meridiem = -1;
+
+        // ----- Second
+        if(match[SECOND_GROUP] != null){
+            var second = parseInt(match[SECOND_GROUP]);
+            if(second >= 60) return null;
+
+            result.start.assign('second', second);
+        }
+
+        // ----- Hours
+        if (match[HOUR_GROUP].toLowerCase().match(/meio\-di/)){
+            meridiem = 1;
+            hour = 12;
+        } else if (match[HOUR_GROUP].toLowerCase() == "meia-noite") {
+            meridiem = 0;
+            hour = 0;
+        } else {
+            hour = parseInt(match[HOUR_GROUP]);
+        }
+
+        // ----- Minutes
+        if(match[MINUTE_GROUP] != null){
+            minute = parseInt(match[MINUTE_GROUP]);
+        } else if(hour > 100) {
+            minute = hour%100;
+            hour   = parseInt(hour/100);
+        }
+
+        if(minute >= 60) {
+            return null;
+        }
+
+        if(hour > 24) {
+            return null;
+        }
+        if (hour >= 12) {
+            meridiem = 1;
+        }
+
+        // ----- AM & PM
+        if(match[AM_PM_HOUR_GROUP] != null) {
+            if(hour > 12) return null;
+            var ampm = match[AM_PM_HOUR_GROUP][0].toLowerCase();
+            if(ampm == "a"){
+                meridiem = 0;
+                if(hour == 12) hour = 0;
+            }
+
+            if(ampm == "p"){
+                meridiem = 1;
+                if(hour != 12) hour += 12;
+            }
+        }
+        result.start.assign('hour', hour);
+        result.start.assign('minute', minute);
+        if (meridiem >= 0) {
+            result.start.assign('meridiem', meridiem);
+        }
+
+        // ==============================================================
+        //                  Extracting the 'to' chunk
+        // ==============================================================
+        match = SECOND_REG_PATTERN.exec(text.substring(result.index + result.text.length));
+        if (!match) {
+            // Not accept number only result
+            if (result.text.match(/^\d+$/)) {
+                return null;
+            }
+            return result;
+        }
+
+
+
+        // Pattern "YY.YY -XXXX" is more like timezone offset
+        if (match[0].match(/^\s*(\+|\-)\s*\d{3,4}$/)) {
+            return result;
+        }
+
+        if(result.end == null){
+            result.end = new ParsedComponents(null, result.start.date());
+        }
+
+        var hour = 0;
+        var minute = 0;
+        var meridiem = -1;
+
+        // ----- Second
+        if(match[SECOND_GROUP] != null){
+            var second = parseInt(match[SECOND_GROUP]);
+            if(second >= 60) return null;
+
+            result.end.assign('second', second);
+        }
+
+        hour = parseInt(match[2]);
+
+        // ----- Minute
+        if (match[MINUTE_GROUP]!= null) {
+
+            minute = parseInt(match[MINUTE_GROUP]);
+            if(minute >= 60) return result;
+
+        } else if (hour > 100) {
+
+            minute = hour%100;
+            hour   = parseInt(hour/100);
+        }
+
+        if(minute >= 60) {
+            return null;
+        }
+
+        if(hour > 24) {
+            return null;
+        }
+        if (hour >= 12) {
+            meridiem = 1;
+        }
+
+        // ----- AM & PM
+        if (match[AM_PM_HOUR_GROUP] != null){
+
+            if (hour > 12) return null;
+
+            if(match[AM_PM_HOUR_GROUP][0].toLowerCase() == "a"){
+                meridiem = 0;
+                if(hour == 12) {
+                    hour = 0;
+                    if (!result.end.isCertain('day')) {
+                        result.end.imply('day', result.end.get('day') + 1);
+                    }
+                }
+            }
+
+            if(match[AM_PM_HOUR_GROUP][0].toLowerCase() == "p"){
+                meridiem = 1;
+                if(hour != 12) hour += 12;
+            }
+
+            if (!result.start.isCertain('meridiem')) {
+                if (meridiem == 0) {
+
+                    result.start.imply('meridiem', 0);
+
+                    if (result.start.get('hour') == 12) {
+                        result.start.assign('hour', 0);
+                    }
+
+                } else {
+
+                    result.start.imply('meridiem', 1);
+
+                    if (result.start.get('hour') != 12) {
+                        result.start.assign('hour', result.start.get('hour') + 12);
+                    }
+                }
+            }
+
+        } else if(hour >= 12) {
+            meridiem = 1;
+        }
+
+        result.text = result.text + match[0];
+        result.end.assign('hour', hour);
+        result.end.assign('minute', minute);
+        if (meridiem >= 0) {
+            result.end.assign('meridiem', meridiem);
+        }
+
+        if (result.end.date().getTime() < result.start.date().getTime()) {
+            result.end.imply('day', result.end.get('day') + 1)
+        }
+
+        return result;
+    }
+}

package/src/parsers/pt/PTWeekdayParser.js

@@ -0,0 +1,60 @@
+var Parser = require('../parser').Parser;
+var ParsedResult = require('../../result').ParsedResult;
+var updateParsedComponent = require('../en/ENWeekdayParser').updateParsedComponent;
+
+var DAYS_OFFSET = { 'domingo': 0, 'dom': 0, 'segunda': 1, 'segunda-feira': 1, 'seg': 1, 'terça': 2, 'terça-feira': 2, 'ter': 2, 'quarta': 3, 'quarta-feira': 3, 'qua': 3,
+    'quinta': 4, 'quinta-feira': 4, 'qui': 4, 'sexta': 5, 'sexta-feira': 5, 'sex': 5, 'sábado': 6, 'sabado': 6, 'sab': 6,}
+
+var PATTERN = new RegExp('(\\W|^)' +
+    '(?:(?:\\,|\\(|\\（)\\s*)?' +
+    '(?:(este|esta|passado|pr[oó]ximo)\\s*)?' +
+    '(' + Object.keys(DAYS_OFFSET).join('|') + ')' +
+    '(?:\\s*(?:\\,|\\)|\\）))?' +
+    '(?:\\s*(este|esta|passado|pr[óo]ximo)\\s*semana)?' +
+    '(?=\\W|$)', 'i');
+
+var PREFIX_GROUP = 2;
+var WEEKDAY_GROUP = 3;
+var POSTFIX_GROUP = 4;
+
+exports.Parser = function PTWeekdayParser() {
+    Parser.apply(this, arguments);
+
+    this.pattern = function() { return PATTERN; }
+
+    this.extract = function(text, ref, match, opt){
+        var index = match.index + match[1].length;
+        var text = match[0].substr(match[1].length, match[0].length - match[1].length);
+        var result = new ParsedResult({
+            index: index,
+            text: text,
+            ref: ref
+        });
+
+        var dayOfWeek = match[WEEKDAY_GROUP].toLowerCase();
+        var offset = DAYS_OFFSET[dayOfWeek];
+        if(offset === undefined) return null;
+
+        var modifier = null;
+        var prefix = match[PREFIX_GROUP];
+        var postfix = match[POSTFIX_GROUP];
+        if (prefix || postfix) {
+            var norm = prefix || postfix;
+            norm = norm.toLowerCase();
+
+            if(norm == 'passado') {
+                modifier = 'this';
+            }
+            else if(norm == 'próximo' || norm == 'proximo') {
+                modifier = 'next';
+            }
+            else if(norm== 'este') {
+                modifier =  'this';
+            }
+        }
+
+        updateParsedComponent(result, ref, offset, modifier);
+        result.tags['PTWeekdayParser'] = true;
+        return result;
+    }
+}