@per-diem-calculator/vanilla 1.0.0

package/src/ts/utils/locations/getCitiesIntl.ts

@@ -0,0 +1,63 @@
+// Types
+import type { Location } from '../../types/locations';
+import type { DateRaw } from '../../types/dates';
+
+// Utils
+import { fetchXmlDOD, parseXml } from '../fetch';
+import { getValidAPIYear } from '../dates';
+import { sortLocations } from './sortLocations';
+import { keepUniqueLocations } from './keepUniqueLocations';
+
+const getCities = (data: string, country: string): Element[] => {
+    return parseXml(
+        data,
+        `//record[country_name[text()="${country.toUpperCase()}"]]`,
+    ) as Element[];
+};
+
+const createLocations = (
+    data: Element[],
+    date: DateRaw,
+    country: string,
+): Location[] => {
+    return data.reduce((result: Location[], record) => {
+        const city = record.querySelector('location_name')?.textContent;
+        const expDateText = record.querySelector('exp_date')?.textContent;
+        const effDateText = record.querySelector('eff_date')?.textContent;
+        if (!city || !expDateText || !effDateText) return result; // City not found, move to next
+
+        const expDate = new Date(
+            `${expDateText.split('/')[2]}-${expDateText.split('/')[0]}-${expDateText.split('/')[1]}`,
+        );
+        const effDate = new Date(
+            `${effDateText.split('/')[2]}-${effDateText.split('/')[0]}-${effDateText.split('/')[1]}`,
+        );
+        const tripDate = new Date(date);
+        if (tripDate > expDate || tripDate < effDate) return result; // Date before rate's effective date, or after rate's expiration date, move to next
+
+        const obj = {
+            city: city,
+            country: country,
+            label: city,
+        };
+        result.push(obj);
+        return result;
+    }, []);
+};
+
+export const getCitiesIntl = async (
+    date: DateRaw,
+    country: string,
+): Promise<Location[]> => {
+    try {
+        return await fetchXmlDOD(getValidAPIYear(date))
+            .then(data => getCities(data, country))
+            .then(data => createLocations(data, date, country))
+            .then(data => sortLocations(data, 'city'))
+            .then(data => keepUniqueLocations(data, 'city'));
+    } catch (error) {
+        throw new Error(
+            `Failed to get int'l cities for ${date} - ${country} - ${error}`,
+        );
+    }
+};

package/src/ts/utils/locations/getCountriesDomestic.ts

@@ -0,0 +1,237 @@
+// Types
+import type { Location } from '../../types/locations';
+import type { DateRaw } from '../../types/dates';
+import type { RateLodging } from '../../types/expenses';
+
+// Utils
+import { fetchJsonGSA } from '../fetch';
+import { getValidAPIYear } from '../dates';
+import { sortLocations } from './sortLocations';
+import { keepUniqueLocations } from './keepUniqueLocations';
+
+const createLocations = (data: RateLodging[]): Location[] => {
+    return data
+        .filter(rate => rate.State !== null && rate.State !== '')
+        .map(rate => {
+            return {
+                country: rate.State,
+                label: LIST_US_STATES.find(
+                    state => state.country === rate.State,
+                )?.label,
+            };
+        });
+};
+
+export const getCountriesDomestic = async (
+    date: DateRaw,
+): Promise<Location[]> => {
+    try {
+        return await fetchJsonGSA<RateLodging>(getValidAPIYear(date), 'lodging')
+            .then(data => createLocations(data))
+            .then(data => sortLocations(data, 'country'))
+            .then(data => keepUniqueLocations(data, 'country'));
+    } catch (error) {
+        throw new Error(
+            `Failed to get domestic countries for ${date} - ${error}`,
+        );
+    }
+};
+
+const LIST_US_STATES: Location[] = [
+    {
+        country: 'AL',
+        label: 'Alabama (AL)',
+    },
+    {
+        country: 'AZ',
+        label: 'Arizona (AZ)',
+    },
+    {
+        country: 'AR',
+        label: 'Arkansas (AR)',
+    },
+    {
+        country: 'CA',
+        label: 'California (CA)',
+    },
+    {
+        country: 'CO',
+        label: 'Colorado (CO)',
+    },
+    {
+        country: 'CT',
+        label: 'Connecticut (CT)',
+    },
+    {
+        country: 'DE',
+        label: 'Delaware (DE)',
+    },
+    {
+        country: 'DC',
+        label: 'District Of Columbia (DC)',
+    },
+    {
+        country: 'FL',
+        label: 'Florida (FL)',
+    },
+    {
+        country: 'GA',
+        label: 'Georgia (GA)',
+    },
+    {
+        country: 'ID',
+        label: 'Idaho (ID)',
+    },
+    {
+        country: 'IL',
+        label: 'Illinois (IL)',
+    },
+    {
+        country: 'IN',
+        label: 'Indiana (IN)',
+    },
+    {
+        country: 'IA',
+        label: 'Iowa (IA)',
+    },
+    {
+        country: 'KS',
+        label: 'Kansas (KS)',
+    },
+    {
+        country: 'KY',
+        label: 'Kentucky (KY)',
+    },
+    {
+        country: 'LA',
+        label: 'Louisiana (LA)',
+    },
+    {
+        country: 'ME',
+        label: 'Maine (ME)',
+    },
+    {
+        country: 'MD',
+        label: 'Maryland (MD)',
+    },
+    {
+        country: 'MA',
+        label: 'Massachusetts (MA)',
+    },
+    {
+        country: 'MI',
+        label: 'Michigan (MI)',
+    },
+    {
+        country: 'MN',
+        label: 'Minnesota (MN)',
+    },
+    {
+        country: 'MS',
+        label: 'Mississippi (MS)',
+    },
+    {
+        country: 'MO',
+        label: 'Missouri (MO)',
+    },
+    {
+        country: 'MT',
+        label: 'Montana (MT)',
+    },
+    {
+        country: 'NE',
+        label: 'Nebraska (NE)',
+    },
+    {
+        country: 'NV',
+        label: 'Nevada (NV)',
+    },
+    {
+        country: 'NH',
+        label: 'New Hampshire (NH)',
+    },
+    {
+        country: 'NJ',
+        label: 'New Jersey (NJ)',
+    },
+    {
+        country: 'NM',
+        label: 'New Mexico (NM)',
+    },
+    {
+        country: 'NY',
+        label: 'New York (NY)',
+    },
+    {
+        country: 'NC',
+        label: 'North Carolina (NC)',
+    },
+    {
+        country: 'ND',
+        label: 'North Dakota (ND)',
+    },
+    {
+        country: 'OH',
+        label: 'Ohio (OH)',
+    },
+    {
+        country: 'OK',
+        label: 'Oklahoma (OK)',
+    },
+    {
+        country: 'OR',
+        label: 'Oregon (OR)',
+    },
+    {
+        country: 'PA',
+        label: 'Pennsylvania (PA)',
+    },
+    {
+        country: 'RI',
+        label: 'Rhode Island (RI)',
+    },
+    {
+        country: 'SC',
+        label: 'South Carolina (SC)',
+    },
+    {
+        country: 'SD',
+        label: 'South Dakota (SD)',
+    },
+    {
+        country: 'TN',
+        label: 'Tennessee (TN)',
+    },
+    {
+        country: 'TX',
+        label: 'Texas (TX)',
+    },
+    {
+        country: 'UT',
+        label: 'Utah (UT)',
+    },
+    {
+        country: 'VT',
+        label: 'Vermont (VT)',
+    },
+    {
+        country: 'VA',
+        label: 'Virginia (VA)',
+    },
+    {
+        country: 'WA',
+        label: 'Washington (WA)',
+    },
+    {
+        country: 'WV',
+        label: 'West Virginia (WV)',
+    },
+    {
+        country: 'WI',
+        label: 'Wisconsin (WI)',
+    },
+    {
+        country: 'WY',
+        label: 'Wyoming (WY)',
+    },
+] as const;

package/src/ts/utils/locations/getCountriesIntl.ts

@@ -0,0 +1,34 @@
+// Types
+import type { Location } from '../../types/locations';
+import type { DateRaw } from '../../types/dates';
+
+// Utils
+import { fetchXmlDOD, parseXml } from '../fetch';
+import { getValidAPIYear } from '../dates';
+import { sortLocations } from './sortLocations';
+import { keepUniqueLocations } from './keepUniqueLocations';
+
+const createLocations = (data: Element[]): Location[] => {
+    return data.reduce((result: Location[], record) => {
+        const country = record.querySelector('country_name')?.textContent;
+        if (!country) return result;
+        const obj = {
+            country: country,
+            label: country,
+        };
+        result.push(obj);
+        return result;
+    }, []);
+};
+
+export const getCountriesIntl = async (date: DateRaw): Promise<Location[]> => {
+    try {
+        return await fetchXmlDOD(getValidAPIYear(date))
+            .then(data => parseXml(data, `//data/*`) as Element[])
+            .then(data => createLocations(data))
+            .then(data => sortLocations(data, 'country'))
+            .then(data => keepUniqueLocations(data, 'country'));
+    } catch (error) {
+        throw new Error(`Failed to get int'l countries for ${date} - ${error}`);
+    }
+};

package/src/ts/utils/locations/index.ts

@@ -0,0 +1,6 @@
+export { getCountriesDomestic } from './getCountriesDomestic';
+export { getCountriesIntl } from './getCountriesIntl';
+export { getCitiesDomestic } from './getCitiesDomestic';
+export { getCitiesIntl } from './getCitiesIntl';
+export { returnValidStateLocation } from './returnValidStateLocation';
+export { locationKeys } from './locationKeys';

package/src/ts/utils/locations/keepUniqueLocations.ts

@@ -0,0 +1,12 @@
+// Types
+import type { Location } from '../../types/locations';
+
+export const keepUniqueLocations = (
+    data: Location[],
+    key: 'country' | 'city',
+): Location[] => {
+    return data.filter((record, i, arr) => {
+        if (i === 0) return true;
+        return record[key] !== arr[i - 1][key];
+    });
+};

package/src/ts/utils/locations/locationKeys.ts

@@ -0,0 +1,10 @@
+// Types
+import { LocationKeys } from '../../types/locations';
+
+export const locationKeys: LocationKeys[] = [
+    'start',
+    'end',
+    'category',
+    'country',
+    'city',
+];

package/src/ts/utils/locations/returnValidStateLocation.ts

@@ -0,0 +1,13 @@
+// Types
+import type {
+    StateLocationItem,
+    StateLocationItemValid,
+} from '../../types/locations';
+
+export const returnValidStateLocation = (
+    location: StateLocationItem,
+): StateLocationItemValid | null => {
+    const { start, end, country, city } = location;
+    if (!(start && end && country && city)) return null;
+    return { start, end, country, city };
+};

package/src/ts/utils/locations/sortLocations.ts

@@ -0,0 +1,19 @@
+// Types
+import type { Location } from '../../types/locations';
+
+export const sortLocations = (
+    data: Location[],
+    key: 'country' | 'city',
+    domesticCities: 'domesticCities' | null = null,
+): Location[] => {
+    if (!domesticCities)
+        return data.sort((a, b) => (a[key] || '').localeCompare(b[key] || ''));
+
+    return data
+        .filter(rate => rate[key] === 'Standard Rate')
+        .concat(
+            data
+                .filter(rate => rate[key] !== 'Standard Rate')
+                .sort((a, b) => (a[key] || '').localeCompare(b[key] || '')),
+        );
+};

package/src/ts/utils/misc/USD.ts

@@ -0,0 +1,4 @@
+export const USD = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+});

package/src/ts/utils/misc/debounce.ts

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Utils
+import { DEBOUNCE_TIME } from '../config';
+
+type TimeoutId = ReturnType<typeof setTimeout> | null;
+type DebouncedFunction = (...args: any[]) => void;
+
+export const debounce = (
+    callback: DebouncedFunction,
+    delay: number = DEBOUNCE_TIME,
+): DebouncedFunction => {
+    let timeoutId: TimeoutId = null;
+    return (...args: any[]): void => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = setTimeout(() => {
+            callback(...args);
+            timeoutId = null; // Reset the timeout
+        }, delay);
+    };
+};

package/src/ts/utils/misc/handlePointerDown.ts

@@ -0,0 +1,3 @@
+export const handlePointerDown = (event: PointerEvent) => {
+    return { pointerStartX: event.clientX, pointerStartY: event.clientY };
+};

package/src/ts/utils/misc/handlePointerUp.ts

@@ -0,0 +1,22 @@
+const tolerance = 5;
+
+export const handlePointerUp = (
+    event: PointerEvent,
+    clickFunction: (e: Event) => void,
+    pointerStartX: number,
+    pointerStartY: number,
+) => {
+    const pointerEndX = event.clientX;
+    const pointerEndY = event.clientY;
+
+    const deltaX = Math.abs(pointerEndX - pointerStartX);
+    const deltaY = Math.abs(pointerEndY - pointerStartY);
+
+    if (deltaX <= tolerance && deltaY <= tolerance && event.button === 0) {
+        // This was a tap or a click, not a drag (no significant movement)
+        clickFunction(event);
+    }
+
+    // Reset pointer coordinates
+    return { pointerStartX: 0, pointerStartY: 0 };
+};

package/src/ts/utils/misc/inPrimitiveType.ts

@@ -0,0 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const inPrimitiveType = <T>(values: readonly T[], x: any): x is T => {
+    return values.includes(x);
+};

package/src/ts/utils/misc/index.ts

@@ -0,0 +1,6 @@
+export { inPrimitiveType } from './inPrimitiveType';
+export { handlePointerDown } from './handlePointerDown';
+export { handlePointerUp } from './handlePointerUp';
+export { USD } from './USD';
+export { debounce } from './debounce';
+export { wait } from './wait';

package/src/ts/utils/misc/wait.ts

@@ -0,0 +1,4 @@
+export const wait = async (ms: number) =>
+    new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });

package/src/ts/utils/styles/applyStyles.ts

@@ -0,0 +1,19 @@
+// Workaround to fully apply Tailwind styles to Shadow DOM
+// https://github.com/tailwindlabs/tailwindcss/issues/15005#issuecomment-2737489813
+
+import styles from '../../../css/_styles.css?inline';
+
+export const applyStyles = (shadowRoot: ShadowRoot) => {
+    const shadowSheet = new CSSStyleSheet();
+    shadowSheet.replaceSync(styles.replace(/:root/gu, ':host'));
+    const properties = [];
+    for (const rule of shadowSheet.cssRules) {
+        if (rule instanceof CSSPropertyRule) {
+            if (rule.initialValue) {
+                properties.push(`${rule.name}: ${rule.initialValue}`);
+            }
+        }
+    }
+    shadowSheet.insertRule(`:host { ${properties.join('; ')} }`);
+    shadowRoot.adoptedStyleSheets = [shadowSheet];
+};

package/src/ts/utils/styles/highlightInput.ts

@@ -0,0 +1,15 @@
+import { BTN_ANIMATE_MS } from '../config';
+
+export const highlightSuccess = (input: HTMLElement | SVGElement) => {
+    input.classList.toggle('success');
+    setTimeout(() => {
+        input.classList.toggle('success');
+    }, BTN_ANIMATE_MS);
+};
+
+export const highlightError = (input: HTMLElement | SVGElement) => {
+    input.classList.toggle('error');
+    setTimeout(() => {
+        input.classList.toggle('error');
+    }, BTN_ANIMATE_MS);
+};

package/src/ts/utils/styles/index.ts

@@ -0,0 +1,3 @@
+export { removeStyles } from '../styles/removeStyles';
+export { applyStyles } from '../styles/applyStyles';
+export { highlightSuccess, highlightError } from '../styles/highlightInput';

package/src/ts/utils/styles/removeStyles.ts

@@ -0,0 +1,14 @@
+export const removeStyles = (HTML: string) => {
+    // Remove all instances of `class="..."`
+    // Remove all instances of `styled="true"`
+    // Remove all SVG elements
+    return HTML.replaceAll(/class="[^"]*"/gi, '')
+        .replaceAll('styled="true"', '')
+        .replaceAll(
+            /<svg[^>]*data-pdc-unstyled="([^"]*)"[^>]*>[\s\S]*?<\/svg>/gi,
+            (_, attributeValue) => {
+                return attributeValue;
+            },
+        )
+        .replaceAll(/<svg[\s\S]*?<\/svg>/gi, '');
+};