@openmrs/esm-utils 6.3.1-pre.2965 → 6.3.1-pre.2997

package/.swcrc

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://swc.rs/schema.json",
+  "exclude": [".*\\.test\\..*", "setup-tests\\..*"],
+  "module": {
+    "type": "es6",
+    "resolveFully": true
+  },
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "tsx": false
+    },
+    "target": "es2020",
+    "baseUrl": "src"
+  }
+}

package/.turbo/turbo-build.log

@@ -1,17 +1,3 @@
-asset openmrs-esm-utils.js 226 KiB [emitted] [minimized] (name: main) 2 related assets
-orphan modules 1.15 MiB [orphan] 735 modules
-runtime modules 937 bytes 4 modules
-built modules 798 KiB [built]
-  modules by path ./ 342 KiB
-    modules by path ./node_modules/semver/functions/*.js 6.71 KiB 24 modules
-    modules by path ./node_modules/semver/ranges/*.js 11.8 KiB 11 modules
-    modules by path ./node_modules/semver/internal/*.js 7.58 KiB 4 modules
-    modules by path ./node_modules/semver/classes/*.js 23.5 KiB 3 modules
-    + 2 modules
-  modules by path ../../../node_modules/ 456 KiB
-    modules by path ../../../node_modules/@formatjs/intl-durationformat/ 322 KiB 13 modules
-    modules by path ../../../node_modules/dayjs/plugin/*.js 3.82 KiB 3 modules
-    ../../../node_modules/tslib/tslib.es6.mjs 17.2 KiB [built] [code generated]
-    ../../../node_modules/@formatjs/intl-localematcher/lib/index.js + 13 modules 113 KiB [built] [code generated]
-  external "dayjs" 42 bytes [built] [code generated]
-webpack 5.88.0 compiled successfully in 11705 ms
+[0] Successfully compiled: 12 files with swc (128.41ms)
+[0] swc --strip-leading-paths src -d dist exited with code 0
+[1] tsc --project tsconfig.build.json exited with code 0

package/dist/age-helpers.d.ts

@@ -0,0 +1,12 @@
+import dayjs from 'dayjs';
+/**
+ * Gets a human readable and locale supported representation of a person's age, given their birthDate,
+ * The representation logic follows the guideline here:
+ * https://webarchive.nationalarchives.gov.uk/ukgwa/20160921162509mp_/http://systems.digital.nhs.uk/data/cui/uig/patben.pdf
+ * (See Tables 7 and 8)
+ *
+ * @param birthDate The birthDate. If birthDate is null, returns null.
+ * @param currentDate Optional. If provided, calculates the age of the person at the provided currentDate (instead of now).
+ * @returns A human-readable string version of the age.
+ */
+export declare function age(birthDate: dayjs.ConfigType, currentDate?: dayjs.ConfigType): string | null;

package/dist/age-helpers.js

@@ -0,0 +1,86 @@
+/** @module @category Utility */ import { DurationFormat } from "@formatjs/intl-durationformat";
+import { attempt } from "any-date-parser";
+import dayjs from "dayjs";
+import objectSupport from "dayjs/plugin/objectSupport.js";
+import { omit } from "lodash-es";
+import { getLocale } from "./get-locale.js";
+dayjs.extend(objectSupport);
+/**
+ * Gets a human readable and locale supported representation of a person's age, given their birthDate,
+ * The representation logic follows the guideline here:
+ * https://webarchive.nationalarchives.gov.uk/ukgwa/20160921162509mp_/http://systems.digital.nhs.uk/data/cui/uig/patben.pdf
+ * (See Tables 7 and 8)
+ *
+ * @param birthDate The birthDate. If birthDate is null, returns null.
+ * @param currentDate Optional. If provided, calculates the age of the person at the provided currentDate (instead of now).
+ * @returns A human-readable string version of the age.
+ */ export function age(birthDate, currentDate = dayjs()) {
+    if (birthDate == null) {
+        return null;
+    }
+    const locale = getLocale();
+    const to = dayjs(currentDate);
+    let from;
+    if (typeof birthDate === 'string') {
+        let parsedDate = attempt(birthDate, locale);
+        if (parsedDate.invalid) {
+            console.warn(`Could not interpret '${birthDate}' as a date`);
+            return null;
+        }
+        // hack here but any date interprets 2000-01, etc. as yyyy-dd rather than yyyy-mm
+        if (parsedDate.day && !parsedDate.month) {
+            parsedDate = Object.assign({}, omit(parsedDate, 'day'), {
+                month: parsedDate.day
+            });
+        }
+        // dayjs' object support uses 0-based months, whereas any-date-parser uses 1-based months
+        if (parsedDate.month) {
+            parsedDate.month -= 1;
+        }
+        // in dayjs day is day of week; in any-date-parser, its day of month, so we need to convert them
+        if (parsedDate.day) {
+            parsedDate = Object.assign({}, omit(parsedDate, 'day'), {
+                date: parsedDate.day
+            });
+        }
+        from = dayjs(to).set(parsedDate);
+    } else {
+        from = dayjs(birthDate);
+    }
+    const hourDiff = to.diff(from, 'hours');
+    const dayDiff = to.diff(from, 'days');
+    const weekDiff = to.diff(from, 'weeks');
+    const monthDiff = to.diff(from, 'months');
+    const yearDiff = to.diff(from, 'years');
+    const duration = {};
+    const options = {
+        style: 'short',
+        localeMatcher: 'lookup'
+    };
+    if (hourDiff < 2) {
+        const minuteDiff = to.diff(from, 'minutes');
+        duration['minutes'] = minuteDiff;
+        if (minuteDiff === 0) {
+            options.minutesDisplay = 'always';
+        }
+    } else if (dayDiff < 2) {
+        duration['hours'] = hourDiff;
+    } else if (weekDiff < 4) {
+        duration['days'] = dayDiff;
+    } else if (yearDiff < 1) {
+        const remainderDayDiff = to.subtract(weekDiff, 'weeks').diff(from, 'days');
+        duration['weeks'] = weekDiff;
+        duration['days'] = remainderDayDiff;
+    } else if (yearDiff < 2) {
+        const remainderDayDiff = to.subtract(monthDiff, 'months').diff(from, 'days');
+        duration['months'] = monthDiff;
+        duration['days'] = remainderDayDiff;
+    } else if (yearDiff < 18) {
+        const remainderMonthDiff = to.subtract(yearDiff, 'year').diff(from, 'months');
+        duration['years'] = yearDiff;
+        duration['months'] = remainderMonthDiff;
+    } else {
+        duration['years'] = yearDiff;
+    }
+    return new DurationFormat(locale, options).format(duration);
+}

package/dist/dates/date-util.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @module
+ * @category Date and Time
+ */
+import { type CalendarDate, type CalendarDateTime, type CalendarIdentifier, type ZonedDateTime } from '@internationalized/date';
+export type DateInput = string | number | Date;
+/**
+ * This function checks whether a date string is the OpenMRS ISO format.
+ * The format should be YYYY-MM-DDTHH:mm:ss.SSSZZ
+ */
+export declare function isOmrsDateStrict(omrsPayloadString: string): boolean;
+/**
+ *
+ * @param date Checks if the provided date is today.
+ */
+export declare function isOmrsDateToday(date: DateInput): boolean;
+/**
+ * Converts the object to a date object if it is an OpenMRS ISO date time string.
+ * Otherwise returns null.
+ */
+export declare function toDateObjectStrict(omrsDateString: string): Date | null;
+/**
+ * Formats the input to OpenMRS ISO format: "YYYY-MM-DDTHH:mm:ss.SSSZZ".
+ */
+export declare function toOmrsIsoString(date: DateInput, toUTC?: boolean): string;
+/**
+ * Utility function to parse an arbitrary string into a date.
+ * Uses `dayjs(dateString)`.
+ */
+export declare function parseDate(dateString: string): Date;
+/**
+ * Provides the name of the calendar to associate, as a default, with the given base locale.
+ *
+ * @example
+ * ```
+ * registerDefaultCalendar('en', 'buddhist') // sets the default calendar for the 'en' locale to Buddhist.
+ * ```
+ *
+ * @param locale the locale to register this calendar for
+ * @param calendar the calendar to use for this registration
+ */
+export declare function registerDefaultCalendar(locale: string, calendar: CalendarIdentifier): void;
+/**
+ * Retrieves the default calendar for the specified locale if any.
+ *
+ * @param locale the locale to look-up
+ */
+export declare function getDefaultCalendar(locale: Intl.Locale | string | undefined): CalendarIdentifier | undefined;
+export type FormatDateMode = 'standard' | 'wide';
+export type FormatDateOptions = {
+    /**
+     * The calendar to use when formatting this date.
+     */
+    calendar?: string;
+    /**
+     * The locale to use when formatting this date
+     */
+    locale?: string;
+    /**
+     * - `standard`: "03 Feb 2022"
+     * - `wide`:     "03 — Feb — 2022"
+     */
+    mode: FormatDateMode;
+    /**
+     * Whether the time should be included in the output always (`true`),
+     * never (`false`), or only when the input date is today (`for today`).
+     */
+    time: true | false | 'for today';
+    /** Whether to include the day number */
+    day: boolean;
+    /** Whether to include the month number */
+    month: boolean;
+    /** Whether to include the year */
+    year: boolean;
+    /** The unicode numbering system to use */
+    numberingSystem?: string;
+    /**
+     * Disables the special handling of dates that are today. If false
+     * (the default), then dates that are today will be formatted as "Today"
+     * in the locale language. If true, then dates that are today will be
+     * formatted the same as all other dates.
+     */
+    noToday: boolean;
+};
+/**
+ * Formats the string representing a date, including partial representations of dates, according to the current
+ * locale and the given options.
+ *
+ * Default options:
+ *  - mode: "standard",
+ *  - time: "for today",
+ *  - day: true,
+ *  - month: true,
+ *  - year: true
+ *  - noToday: false
+ *
+ * If the date is today then "Today" is produced (in the locale language).
+ * This behavior can be disabled with `noToday: true`.
+ *
+ * When time is included, it is appended with a comma and a space. This
+ * agrees with the output of `Date.prototype.toLocaleString` for *most*
+ * locales.
+ */
+export declare function formatPartialDate(dateString: string, options?: Partial<FormatDateOptions>): string | null;
+/**
+ * Formats the input date according to the current locale and the
+ * given options.
+ *
+ * Default options:
+ *  - mode: "standard",
+ *  - time: "for today",
+ *  - day: true,
+ *  - month: true,
+ *  - year: true
+ *  - noToday: false
+ *
+ * If the date is today then "Today" is produced (in the locale language).
+ * This behavior can be disabled with `noToday: true`.
+ *
+ * When time is included, it is appended with a comma and a space. This
+ * agrees with the output of `Date.prototype.toLocaleString` for *most*
+ * locales.
+ */
+export declare function formatDate(date: Date, options?: Partial<FormatDateOptions>): string;
+/**
+ * Formats the input as a time, according to the current locale.
+ * 12-hour or 24-hour clock depends on locale.
+ */
+export declare function formatTime(date: Date): string;
+/**
+ * Formats the input into a string showing the date and time, according
+ * to the current locale. The `mode` parameter is as described for
+ * `formatDate`.
+ *
+ * This is created by concatenating the results of `formatDate`
+ * and `formatTime` with a comma and space. This agrees with the
+ * output of `Date.prototype.toLocaleString` for *most* locales.
+ */
+export declare function formatDatetime(date: Date, options?: Partial<Omit<FormatDateOptions, 'time'>>): string;
+/**
+ * Converts a calendar date to the equivalent locale calendar date.
+ * @returns CalendarDate
+ */
+export declare function convertToLocaleCalendar(date: CalendarDate | CalendarDateTime | ZonedDateTime, locale: string | Intl.Locale): CalendarDate | CalendarDateTime | ZonedDateTime;

package/dist/dates/date-util.js

@@ -0,0 +1,335 @@
+/**
+ * @module
+ * @category Date and Time
+ */ function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+import { createCalendar, toCalendar } from "@internationalized/date";
+import { attempt } from "any-date-parser";
+import dayjs from "dayjs";
+import isToday from "dayjs/plugin/isToday.js";
+import objectSupport from "dayjs/plugin/objectSupport.js";
+import utc from "dayjs/plugin/utc.js";
+import { isNil, omit } from "lodash-es";
+import { getLocale } from "../index.js";
+dayjs.extend(isToday);
+dayjs.extend(utc);
+dayjs.extend(objectSupport);
+const isoFormat = 'YYYY-MM-DDTHH:mm:ss.SSSZZ';
+/**
+ * This function checks whether a date string is the OpenMRS ISO format.
+ * The format should be YYYY-MM-DDTHH:mm:ss.SSSZZ
+ */ export function isOmrsDateStrict(omrsPayloadString) {
+    // omrs format 2018-03-19T00:00:00.000+0300
+    if (omrsPayloadString === null || omrsPayloadString === undefined || omrsPayloadString.trim().length !== 28) {
+        return false;
+    }
+    omrsPayloadString = omrsPayloadString.trim();
+    // 11th character will always be T
+    if (omrsPayloadString[10] !== 'T') {
+        return false;
+    }
+    // checking time format
+    if (omrsPayloadString[13] !== ':' || omrsPayloadString[16] !== ':' || omrsPayloadString[19] !== '.') {
+        return false;
+    }
+    // checking UTC offset format
+    if (!(omrsPayloadString[23] === '+' || omrsPayloadString[23] === '-')) {
+        return false;
+    }
+    return dayjs(omrsPayloadString, isoFormat).isValid();
+}
+/**
+ *
+ * @param date Checks if the provided date is today.
+ */ export function isOmrsDateToday(date) {
+    return dayjs(date).isToday();
+}
+/**
+ * Converts the object to a date object if it is an OpenMRS ISO date time string.
+ * Otherwise returns null.
+ */ export function toDateObjectStrict(omrsDateString) {
+    if (!isOmrsDateStrict(omrsDateString)) {
+        return null;
+    }
+    return dayjs(omrsDateString, isoFormat).toDate();
+}
+/**
+ * Formats the input to OpenMRS ISO format: "YYYY-MM-DDTHH:mm:ss.SSSZZ".
+ */ export function toOmrsIsoString(date, toUTC = false) {
+    let d = dayjs(date);
+    if (toUTC) {
+        d = d.utc();
+    }
+    return d.format(isoFormat);
+}
+/**
+ * Utility function to parse an arbitrary string into a date.
+ * Uses `dayjs(dateString)`.
+ */ export function parseDate(dateString) {
+    return dayjs(dateString).toDate();
+}
+var _registry = /*#__PURE__*/ new WeakMap();
+/**
+ * Internal cache for per-locale calendars
+ */ class LocaleCalendars {
+    register(locale, calendar) {
+        _class_private_field_get(this, _registry).set(locale, calendar);
+    }
+    getCalendar(locale) {
+        if (!Boolean(locale)) {
+            return undefined;
+        }
+        if (locale.calendar) {
+            return locale.calendar;
+        }
+        if (locale.region) {
+            const key = `${locale.language}-${locale.region}`;
+            if (_class_private_field_get(this, _registry).has(key)) {
+                return _class_private_field_get(this, _registry).get(key);
+            }
+        }
+        if (locale.language && _class_private_field_get(this, _registry).has(locale.language)) {
+            return _class_private_field_get(this, _registry).get(locale.language);
+        }
+        const defaultCalendar = new Intl.DateTimeFormat(locale.toString()).resolvedOptions().calendar;
+        // cache this result
+        _class_private_field_get(this, _registry).set(`${locale.language}${locale.region ? `-${locale.region}` : ''}`, defaultCalendar);
+        return defaultCalendar;
+    }
+    constructor(){
+        _class_private_field_init(this, _registry, {
+            writable: true,
+            value: new Map()
+        });
+    }
+}
+const registeredLocaleCalendars = new LocaleCalendars();
+/**
+ * Provides the name of the calendar to associate, as a default, with the given base locale.
+ *
+ * @example
+ * ```
+ * registerDefaultCalendar('en', 'buddhist') // sets the default calendar for the 'en' locale to Buddhist.
+ * ```
+ *
+ * @param locale the locale to register this calendar for
+ * @param calendar the calendar to use for this registration
+ */ export function registerDefaultCalendar(locale, calendar) {
+    registeredLocaleCalendars.register(locale, calendar);
+}
+/**
+ * Retrieves the default calendar for the specified locale if any.
+ *
+ * @param locale the locale to look-up
+ */ export function getDefaultCalendar(locale) {
+    const locale_ = locale ?? getLocale();
+    return registeredLocaleCalendars.getCalendar(locale_ instanceof Intl.Locale ? locale_ : new Intl.Locale(locale_));
+}
+const defaultOptions = {
+    mode: 'standard',
+    time: 'for today',
+    day: true,
+    month: true,
+    year: true,
+    noToday: false
+};
+/**
+ * Formats the string representing a date, including partial representations of dates, according to the current
+ * locale and the given options.
+ *
+ * Default options:
+ *  - mode: "standard",
+ *  - time: "for today",
+ *  - day: true,
+ *  - month: true,
+ *  - year: true
+ *  - noToday: false
+ *
+ * If the date is today then "Today" is produced (in the locale language).
+ * This behavior can be disabled with `noToday: true`.
+ *
+ * When time is included, it is appended with a comma and a space. This
+ * agrees with the output of `Date.prototype.toLocaleString` for *most*
+ * locales.
+ */ // TODO: Shouldn't throw on null input
+export function formatPartialDate(dateString, options = {}) {
+    const locale = getLocale();
+    let parsed = attempt(dateString, locale);
+    if (parsed.invalid) {
+        console.warn(`Could not parse invalid date '${dateString}'`);
+        return null;
+    }
+    // hack here but any date interprets 2000-01, etc. as yyyy-dd rather than yyyy-mm
+    if (!isNil(parsed.day) && isNil(parsed.month)) {
+        parsed = Object.assign({}, omit(parsed, 'day'), {
+            month: parsed.day
+        });
+    }
+    // dayjs' object support uses 0-based months, whereas any-date-parser uses 1-based months
+    if (parsed.month) {
+        parsed.month -= 1;
+    }
+    // in dayjs day is day of week; in any-date-parser, its day of month, so we need to convert them
+    if (parsed.day) {
+        parsed = Object.assign({}, omit(parsed, 'day'), {
+            date: parsed.day
+        });
+    }
+    const date = dayjs().set(parsed).toDate();
+    if (isNil(parsed.year)) {
+        options.year = false;
+    }
+    if (isNil(parsed.month)) {
+        options.month = false;
+    }
+    if (isNil(parsed.date)) {
+        options.day = false;
+    }
+    return formatDate(date, options);
+}
+/**
+ * Formats the input date according to the current locale and the
+ * given options.
+ *
+ * Default options:
+ *  - mode: "standard",
+ *  - time: "for today",
+ *  - day: true,
+ *  - month: true,
+ *  - year: true
+ *  - noToday: false
+ *
+ * If the date is today then "Today" is produced (in the locale language).
+ * This behavior can be disabled with `noToday: true`.
+ *
+ * When time is included, it is appended with a comma and a space. This
+ * agrees with the output of `Date.prototype.toLocaleString` for *most*
+ * locales.
+ */ // TODO: Shouldn't throw on null input
+export function formatDate(date, options) {
+    let locale = options?.locale ?? getLocale();
+    const _locale = new Intl.Locale(locale);
+    const { calendar, mode, time, day, month, year, noToday, numberingSystem } = {
+        ...defaultOptions,
+        ...{
+            noToday: _locale.language === 'am' ? true : false
+        },
+        ...options
+    };
+    const formatCalendar = calendar ?? getDefaultCalendar(_locale);
+    const formatterOptions = {
+        calendar: formatCalendar,
+        year: year ? 'numeric' : undefined,
+        month: month ? 'short' : undefined,
+        day: day ? '2-digit' : undefined,
+        numberingSystem
+    };
+    let localeString;
+    const isToday = dayjs(date).isToday();
+    if (isToday && !noToday) {
+        // This produces the word "Today" in the language of `locale`
+        const rtf = new Intl.RelativeTimeFormat(locale, {
+            numeric: 'auto'
+        });
+        localeString = rtf.format(0, 'day');
+        localeString = localeString[0].toLocaleUpperCase(locale) + localeString.slice(1);
+    } else {
+        if (_locale.language === 'en') {
+            // This locale override is here rather than in `getLocale`
+            // because Americans should see AM/PM for times.
+            locale = 'en-GB';
+        }
+        const formatter = new Intl.DateTimeFormat(locale, formatterOptions);
+        let parts = formatter.formatToParts(date);
+        if ((_locale.language === 'en' || _locale.language === 'am') && mode == 'standard' && year && day) {
+            // Custom formatting for English and Amharic. Use hyphens instead of spaces.
+            parts = parts.map(formatParts('-'));
+        }
+        if (mode == 'wide') {
+            parts = parts.map(formatParts(' — ')); // space-emdash-space
+        }
+        // omit the era when using the Ethiopic calendar
+        if (formatterOptions.calendar === 'ethiopic') {
+            parts = parts.filter((part, idx, values)=>{
+                if (part.type === 'era' || part.type === 'literal' && idx < values.length - 1 && values[idx + 1].type === 'era') {
+                    return false;
+                }
+                return true;
+            });
+        }
+        localeString = parts.map((p)=>p.value).join('');
+    }
+    if (time === true || isToday && time === 'for today') {
+        localeString += `, ${formatTime(date)}`;
+    }
+    return localeString;
+}
+// Internal curried call-back for map()
+const formatParts = (separator)=>{
+    return (part, idx, values)=>{
+        if (part.type !== 'literal' || part.value !== ' ') {
+            return part;
+        }
+        if (idx < values.length - 1 && values[idx + 1].type === 'era') {
+            return part;
+        }
+        return {
+            type: 'literal',
+            value: separator
+        };
+    };
+};
+/**
+ * Formats the input as a time, according to the current locale.
+ * 12-hour or 24-hour clock depends on locale.
+ */ export function formatTime(date) {
+    return date.toLocaleTimeString(getLocale(), {
+        hour: '2-digit',
+        minute: '2-digit'
+    });
+}
+/**
+ * Formats the input into a string showing the date and time, according
+ * to the current locale. The `mode` parameter is as described for
+ * `formatDate`.
+ *
+ * This is created by concatenating the results of `formatDate`
+ * and `formatTime` with a comma and space. This agrees with the
+ * output of `Date.prototype.toLocaleString` for *most* locales.
+ */ export function formatDatetime(date, options) {
+    return formatDate(date, {
+        ...options,
+        time: true
+    });
+}
+/**
+ * Converts a calendar date to the equivalent locale calendar date.
+ * @returns CalendarDate
+ */ export function convertToLocaleCalendar(date, locale) {
+    let locale_ = typeof locale === 'string' ? new Intl.Locale(locale) : locale;
+    const localCalendarName = getDefaultCalendar(locale_);
+    return localCalendarName ? toCalendar(date, createCalendar(localCalendarName)) : date;
+}

package/dist/dates/index.d.ts

@@ -0,0 +1 @@
+export * from './date-util';

package/dist/dates/index.js

@@ -0,0 +1 @@
+export * from "./date-util.js";

package/dist/get-locale.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns the current locale of the application.
+ * @returns string
+ */
+export declare function getLocale(): string;

package/dist/get-locale.js

@@ -0,0 +1,13 @@
+/**
+ * Returns the current locale of the application.
+ * @returns string
+ */ export function getLocale() {
+    let language = window.i18next.language;
+    language = language.replace('_', '-'); // just in case
+    // Hack for `ht` until all browsers update their unicode support with ht to fr mapping.
+    // See https://unicode-org.atlassian.net/browse/CLDR-14956
+    if (language === 'ht') {
+        language = 'fr-HT';
+    }
+    return language;
+}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from './age-helpers';
+export * from './dates';
+export * from './get-locale';
+export * from './is-online';
+export * from './patient-helpers';
+export * from './shallowEqual';
+export * from './storage';
+export * from './test-helpers';
+export * from './version';
+export * from './retry';

package/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./age-helpers.js";
+export * from "./dates/index.js";
+export * from "./get-locale.js";
+export * from "./is-online.js";
+export * from "./patient-helpers.js";
+export * from "./shallowEqual.js";
+export * from "./storage.js";
+export * from "./test-helpers.js";
+export * from "./version.js";
+export * from "./retry.js";

package/dist/is-online.d.ts

@@ -0,0 +1 @@
+export declare function isOnline(online?: boolean): boolean;

package/dist/is-online.js

@@ -0,0 +1,3 @@
+export function isOnline(online) {
+    return window.offlineEnabled ? online ?? navigator.onLine : true;
+}