art-bd-ui 1.0.21 → 1.0.23

package/dist/esm/node_modules/chrono-node/dist/esm/locales/uk/parsers/UKTimeExpressionParser.js

@@ -0,0 +1,56 @@
+import { Meridiem } from '../../../types.js';
+import { AbstractTimeExpressionParser } from '../../../common/parsers/AbstractTimeExpressionParser.js';
+import { REGEX_PARTS } from '../constants.js';
+
+class UKTimeExpressionParser extends AbstractTimeExpressionParser {
+    constructor(strictMode) {
+        super(strictMode);
+    }
+    patternFlags() {
+        return REGEX_PARTS.flags;
+    }
+    primaryPatternLeftBoundary() {
+        return `(^|\\s|T|(?:[^\\p{L}\\p{N}_]))`;
+    }
+    followingPhase() {
+        return `\\s*(?:\\-|\\–|\\~|\\〜|до|і|по|\\?)\\s*`;
+    }
+    primaryPrefix() {
+        return `(?:(?:в|у|о|об|з|із|від)\\s*)??`;
+    }
+    primarySuffix() {
+        return `(?:\\s*(?:ранку|вечора|по обіді|після обіду))?(?!\\/)${REGEX_PARTS.rightBoundary}`;
+    }
+    extractPrimaryTimeComponents(context, match) {
+        const components = super.extractPrimaryTimeComponents(context, match);
+        if (components) {
+            if (match[0].endsWith("вечора")) {
+                const hour = components.get("hour");
+                if (hour >= 6 && hour < 12) {
+                    components.assign("hour", components.get("hour") + 12);
+                    components.assign("meridiem", Meridiem.PM);
+                }
+                else if (hour < 6) {
+                    components.assign("meridiem", Meridiem.AM);
+                }
+            }
+            if (match[0].endsWith("по обіді") || match[0].endsWith("після обіду")) {
+                components.assign("meridiem", Meridiem.PM);
+                const hour = components.get("hour");
+                if (hour >= 0 && hour <= 6) {
+                    components.assign("hour", components.get("hour") + 12);
+                }
+            }
+            if (match[0].endsWith("ранку")) {
+                components.assign("meridiem", Meridiem.AM);
+                const hour = components.get("hour");
+                if (hour < 12) {
+                    components.assign("hour", components.get("hour"));
+                }
+            }
+        }
+        return components;
+    }
+}
+
+export { UKTimeExpressionParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/uk/parsers/UKTimeUnitAgoFormatParser.js

@@ -0,0 +1,17 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import { reverseTimeUnits } from '../../../utils/timeunits.js';
+import { AbstractParserWithLeftBoundaryChecking } from './AbstractParserWithWordBoundaryChecking.js';
+
+class UKTimeUnitAgoFormatParser extends AbstractParserWithLeftBoundaryChecking {
+    innerPatternString(context) {
+        return `(${TIME_UNITS_PATTERN})\\s{0,5}тому(?=(?:\\W|$))`;
+    }
+    innerExtract(context, match) {
+        const timeUnits = parseTimeUnits(match[1]);
+        const outputTimeUnits = reverseTimeUnits(timeUnits);
+        return ParsingComponents.createRelativeFromReference(context.reference, outputTimeUnits);
+    }
+}
+
+export { UKTimeUnitAgoFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/uk/parsers/UKTimeUnitCasualRelativeFormatParser.js

@@ -0,0 +1,24 @@
+import { TIME_UNITS_PATTERN, parseTimeUnits } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import { reverseTimeUnits } from '../../../utils/timeunits.js';
+import { AbstractParserWithLeftRightBoundaryChecking } from './AbstractParserWithWordBoundaryChecking.js';
+
+class UKTimeUnitCasualRelativeFormatParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return `(ці|останні|минулі|майбутні|наступні|після|через|\\+|-)\\s*(${TIME_UNITS_PATTERN})`;
+    }
+    innerExtract(context, match) {
+        const prefix = match[1].toLowerCase();
+        let timeUnits = parseTimeUnits(match[3]);
+        switch (prefix) {
+            case "останні":
+            case "минулі":
+            case "-":
+                timeUnits = reverseTimeUnits(timeUnits);
+                break;
+        }
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+export { UKTimeUnitCasualRelativeFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/uk/parsers/UKTimeUnitWithinFormatParser.js

@@ -0,0 +1,21 @@
+import { REGEX_PARTS, TIME_UNITS_PATTERN, parseTimeUnits } from '../constants.js';
+import { ParsingComponents } from '../../../results.js';
+import { AbstractParserWithWordBoundaryChecking } from '../../../common/parsers/AbstractParserWithWordBoundary.js';
+
+const PATTERN = `(?:(?:приблизно|орієнтовно)\\s*(?:~\\s*)?)?(${TIME_UNITS_PATTERN})${REGEX_PARTS.rightBoundary}`;
+class UKTimeUnitWithinFormatParser extends AbstractParserWithWordBoundaryChecking {
+    patternLeftBoundary() {
+        return REGEX_PARTS.leftBoundary;
+    }
+    innerPattern(context) {
+        return context.option.forwardDate
+            ? new RegExp(PATTERN, "i")
+            : new RegExp(`(?:протягом|на протязі|протягом|упродовж|впродовж)\\s*${PATTERN}`, REGEX_PARTS.flags);
+    }
+    innerExtract(context, match) {
+        const timeUnits = parseTimeUnits(match[1]);
+        return ParsingComponents.createRelativeFromReference(context.reference, timeUnits);
+    }
+}
+
+export { UKTimeUnitWithinFormatParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/uk/parsers/UKWeekdayParser.js

@@ -0,0 +1,44 @@
+import { WEEKDAY_DICTIONARY } from '../constants.js';
+import { matchAnyPattern } from '../../../utils/pattern.js';
+import { createParsingComponentsAtWeekday } from '../../../common/calculation/weekdays.js';
+import { AbstractParserWithLeftRightBoundaryChecking } from './AbstractParserWithWordBoundaryChecking.js';
+
+const PREFIX_GROUP = 1;
+const WEEKDAY_GROUP = 2;
+const POSTFIX_GROUP = 3;
+class UKWeekdayParser extends AbstractParserWithLeftRightBoundaryChecking {
+    innerPatternString(context) {
+        return (`(?:(?:,|\\(|（)\\s*)?` +
+            `(?:в\\s*?)?` +
+            `(?:у\\s*?)?` +
+            `(?:(цей|минулого|минулий|попередній|попереднього|наступного|наступний|наступному)\\s*)?` +
+            `(${matchAnyPattern(WEEKDAY_DICTIONARY)})` +
+            `(?:\\s*(?:,|\\)|）))?` +
+            `(?:\\s*(на|у|в)\\s*(цьому|минулому|наступному)\\s*тижні)?`);
+    }
+    innerExtract(context, match) {
+        const dayOfWeek = match[WEEKDAY_GROUP].toLocaleLowerCase();
+        const weekday = WEEKDAY_DICTIONARY[dayOfWeek];
+        const prefix = match[PREFIX_GROUP];
+        const postfix = match[POSTFIX_GROUP];
+        let modifierWord = prefix || postfix;
+        modifierWord = modifierWord || "";
+        modifierWord = modifierWord.toLocaleLowerCase();
+        let modifier = null;
+        if (modifierWord == "минулого" ||
+            modifierWord == "минулий" ||
+            modifierWord == "попередній" ||
+            modifierWord == "попереднього") {
+            modifier = "last";
+        }
+        else if (modifierWord == "наступного" || modifierWord == "наступний") {
+            modifier = "next";
+        }
+        else if (modifierWord == "цей" || modifierWord == "цього" || modifierWord == "цьому") {
+            modifier = "this";
+        }
+        return createParsingComponentsAtWeekday(context.reference, weekday, modifier);
+    }
+}
+
+export { UKWeekdayParser as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/uk/refiners/UKMergeDateRangeRefiner.js

@@ -0,0 +1,9 @@
+import AbstractMergeDateRangeRefiner from '../../../common/refiners/AbstractMergeDateRangeRefiner.js';
+
+class UKMergeDateRangeRefiner extends AbstractMergeDateRangeRefiner {
+    patternBetween() {
+        return /^\s*(і до|і по|до|по|-)\s*$/i;
+    }
+}
+
+export { UKMergeDateRangeRefiner as default };

package/dist/esm/node_modules/chrono-node/dist/esm/locales/uk/refiners/UKMergeDateTimeRefiner.js

@@ -0,0 +1,9 @@
+import AbstractMergeDateTimeRefiner from '../../../common/refiners/AbstractMergeDateTimeRefiner.js';
+
+class UKMergeDateTimeRefiner extends AbstractMergeDateTimeRefiner {
+    patternBetween() {
+        return new RegExp(`^\\s*(T|в|у|о|,|-)?\\s*$`);
+    }
+}
+
+export { UKMergeDateTimeRefiner as default };

package/dist/esm/node_modules/chrono-node/dist/esm/results.js

@@ -0,0 +1,265 @@
+import quarterOfYear from '../../../../_virtual/quarterOfYear.js';
+import dayjs from '../../../../_virtual/dayjs.min.js';
+import { assignSimilarTime, assignSimilarDate, implySimilarTime } from './utils/dayjs.js';
+import { toTimezoneOffset } from './timezone.js';
+
+dayjs.extend(quarterOfYear);
+class ReferenceWithTimezone {
+    instant;
+    timezoneOffset;
+    constructor(input) {
+        input = input ?? new Date();
+        if (input instanceof Date) {
+            this.instant = input;
+            this.timezoneOffset = null;
+        }
+        else {
+            this.instant = input.instant ?? new Date();
+            this.timezoneOffset = toTimezoneOffset(input.timezone, this.instant);
+        }
+    }
+    getDateWithAdjustedTimezone() {
+        const date = new Date(this.instant);
+        if (this.timezoneOffset !== null) {
+            date.setMinutes(date.getMinutes() - this.getSystemTimezoneAdjustmentMinute(this.instant));
+        }
+        return date;
+    }
+    getSystemTimezoneAdjustmentMinute(date, overrideTimezoneOffset) {
+        if (!date || date.getTime() < 0) {
+            date = new Date();
+        }
+        const currentTimezoneOffset = -date.getTimezoneOffset();
+        const targetTimezoneOffset = overrideTimezoneOffset ?? this.timezoneOffset ?? currentTimezoneOffset;
+        return currentTimezoneOffset - targetTimezoneOffset;
+    }
+    getTimezoneOffset() {
+        return this.timezoneOffset ?? -this.instant.getTimezoneOffset();
+    }
+}
+class ParsingComponents {
+    knownValues;
+    impliedValues;
+    reference;
+    _tags = new Set();
+    constructor(reference, knownComponents) {
+        this.reference = reference;
+        this.knownValues = {};
+        this.impliedValues = {};
+        if (knownComponents) {
+            for (const key in knownComponents) {
+                this.knownValues[key] = knownComponents[key];
+            }
+        }
+        const refDayJs = reference.getDateWithAdjustedTimezone();
+        this.imply("day", refDayJs.getDate());
+        this.imply("month", refDayJs.getMonth() + 1);
+        this.imply("year", refDayJs.getFullYear());
+        this.imply("hour", 12);
+        this.imply("minute", 0);
+        this.imply("second", 0);
+        this.imply("millisecond", 0);
+    }
+    get(component) {
+        if (component in this.knownValues) {
+            return this.knownValues[component];
+        }
+        if (component in this.impliedValues) {
+            return this.impliedValues[component];
+        }
+        return null;
+    }
+    isCertain(component) {
+        return component in this.knownValues;
+    }
+    getCertainComponents() {
+        return Object.keys(this.knownValues);
+    }
+    imply(component, value) {
+        if (component in this.knownValues) {
+            return this;
+        }
+        this.impliedValues[component] = value;
+        return this;
+    }
+    assign(component, value) {
+        this.knownValues[component] = value;
+        delete this.impliedValues[component];
+        return this;
+    }
+    delete(component) {
+        delete this.knownValues[component];
+        delete this.impliedValues[component];
+    }
+    clone() {
+        const component = new ParsingComponents(this.reference);
+        component.knownValues = {};
+        component.impliedValues = {};
+        for (const key in this.knownValues) {
+            component.knownValues[key] = this.knownValues[key];
+        }
+        for (const key in this.impliedValues) {
+            component.impliedValues[key] = this.impliedValues[key];
+        }
+        return component;
+    }
+    isOnlyDate() {
+        return !this.isCertain("hour") && !this.isCertain("minute") && !this.isCertain("second");
+    }
+    isOnlyTime() {
+        return (!this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month") && !this.isCertain("year"));
+    }
+    isOnlyWeekdayComponent() {
+        return this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
+    }
+    isDateWithUnknownYear() {
+        return this.isCertain("month") && !this.isCertain("year");
+    }
+    isValidDate() {
+        const date = this.dateWithoutTimezoneAdjustment();
+        if (date.getFullYear() !== this.get("year"))
+            return false;
+        if (date.getMonth() !== this.get("month") - 1)
+            return false;
+        if (date.getDate() !== this.get("day"))
+            return false;
+        if (this.get("hour") != null && date.getHours() != this.get("hour"))
+            return false;
+        if (this.get("minute") != null && date.getMinutes() != this.get("minute"))
+            return false;
+        return true;
+    }
+    toString() {
+        return `[ParsingComponents {
+            tags: ${JSON.stringify(Array.from(this._tags).sort())}, 
+            knownValues: ${JSON.stringify(this.knownValues)}, 
+            impliedValues: ${JSON.stringify(this.impliedValues)}}, 
+            reference: ${JSON.stringify(this.reference)}]`;
+    }
+    dayjs() {
+        return dayjs(this.dateWithoutTimezoneAdjustment());
+    }
+    date() {
+        const date = this.dateWithoutTimezoneAdjustment();
+        const timezoneAdjustment = this.reference.getSystemTimezoneAdjustmentMinute(date, this.get("timezoneOffset"));
+        return new Date(date.getTime() + timezoneAdjustment * 60000);
+    }
+    addTag(tag) {
+        this._tags.add(tag);
+        return this;
+    }
+    addTags(tags) {
+        for (const tag of tags) {
+            this._tags.add(tag);
+        }
+        return this;
+    }
+    tags() {
+        return new Set(this._tags);
+    }
+    dateWithoutTimezoneAdjustment() {
+        const date = new Date(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond"));
+        date.setFullYear(this.get("year"));
+        return date;
+    }
+    static createRelativeFromReference(reference, fragments) {
+        let date = dayjs(reference.getDateWithAdjustedTimezone());
+        for (const key in fragments) {
+            date = date.add(fragments[key], key);
+        }
+        const components = new ParsingComponents(reference);
+        components.addTag("result/relativeDate");
+        if (fragments["hour"] || fragments["minute"] || fragments["second"]) {
+            components.addTag("result/relativeDateAndTime");
+            assignSimilarTime(components, date);
+            assignSimilarDate(components, date);
+            components.assign("timezoneOffset", reference.getTimezoneOffset());
+        }
+        else {
+            implySimilarTime(components, date);
+            components.imply("timezoneOffset", reference.getTimezoneOffset());
+            if (fragments["d"]) {
+                components.assign("day", date.date());
+                components.assign("month", date.month() + 1);
+                components.assign("year", date.year());
+            }
+            else if (fragments["week"]) {
+                components.assign("day", date.date());
+                components.assign("month", date.month() + 1);
+                components.assign("year", date.year());
+                components.imply("weekday", date.day());
+            }
+            else {
+                components.imply("day", date.date());
+                if (fragments["month"]) {
+                    components.assign("month", date.month() + 1);
+                    components.assign("year", date.year());
+                }
+                else {
+                    components.imply("month", date.month() + 1);
+                    if (fragments["year"]) {
+                        components.assign("year", date.year());
+                    }
+                    else {
+                        components.imply("year", date.year());
+                    }
+                }
+            }
+        }
+        return components;
+    }
+}
+class ParsingResult {
+    refDate;
+    index;
+    text;
+    reference;
+    start;
+    end;
+    constructor(reference, index, text, start, end) {
+        this.reference = reference;
+        this.refDate = reference.instant;
+        this.index = index;
+        this.text = text;
+        this.start = start || new ParsingComponents(reference);
+        this.end = end;
+    }
+    clone() {
+        const result = new ParsingResult(this.reference, this.index, this.text);
+        result.start = this.start ? this.start.clone() : null;
+        result.end = this.end ? this.end.clone() : null;
+        return result;
+    }
+    date() {
+        return this.start.date();
+    }
+    addTag(tag) {
+        this.start.addTag(tag);
+        if (this.end) {
+            this.end.addTag(tag);
+        }
+        return this;
+    }
+    addTags(tags) {
+        this.start.addTags(tags);
+        if (this.end) {
+            this.end.addTags(tags);
+        }
+        return this;
+    }
+    tags() {
+        const combinedTags = new Set(this.start.tags());
+        if (this.end) {
+            for (const tag of this.end.tags()) {
+                combinedTags.add(tag);
+            }
+        }
+        return combinedTags;
+    }
+    toString() {
+        const tags = Array.from(this.tags()).sort();
+        return `[ParsingResult {index: ${this.index}, text: '${this.text}', tags: ${JSON.stringify(tags)} ...}]`;
+    }
+}
+
+export { ParsingComponents, ParsingResult, ReferenceWithTimezone };