@actual-app/core 26.3.0

package/src/shared/months.test.ts

@@ -0,0 +1,5 @@
+import * as monthUtils from './months';
+
+test('range returns a full range', () => {
+  expect(monthUtils.range('2016-10', '2018-01')).toMatchSnapshot();
+});

package/src/shared/months.ts

@@ -0,0 +1,485 @@
+// @ts-strict-ignore
+import * as d from 'date-fns';
+import type { Locale } from 'date-fns';
+import memoizeOne from 'memoize-one';
+
+import type { SyncedPrefs } from '../types/prefs';
+
+import * as Platform from './platform';
+
+type DateLike = string | Date;
+type Day = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+
+export function _parse(value: DateLike): Date {
+  if (typeof value === 'string') {
+    // Dates are hard. We just want to deal with months in the format
+    // 2020-01 and days in the format 2020-01-01, but life is never
+    // simple. We want to rely on native dates for date logic because
+    // days are complicated (leap years, etc). But relying on native
+    // dates mean we're exposed to craziness.
+    //
+    // The biggest problem is that JS dates work with local time by
+    // default. We could try to only work with UTC, but there's not an
+    // easy way to make `format` avoid local time, and not sure if we
+    // want that anyway (`currentMonth` should surely print the local
+    // time). We need to embrace local time, and as long as inputs to
+    // date logic and outputs from format are local time, it should
+    // work.
+    //
+    // To make sure we're in local time, always give Date integer
+    // values. If you pass in a string to parse, different string
+    // formats produce different results.
+    //
+    // A big problem is daylight savings, however. Usually, when
+    // giving the time to the Date constructor, you get back a date
+    // specifically for that time in your local timezone. However, if
+    // daylight savings occurs on that exact time, you will get back
+    // something different:
+    //
+    // This is fine:
+    // > new Date(2017, 2, 12, 1).toString()
+    // > 'Sun Mar 12 2017 01:00:00 GMT-0500 (Eastern Standard Time)'
+    //
+    // But wait, we got back a different time (3AM instead of 2AM):
+    // > new Date(2017, 2, 12, 2).toString()
+    // > 'Sun Mar 12 2017 03:00:00 GMT-0400 (Eastern Daylight Time)'
+    //
+    // The time is "correctly" adjusted via DST, but we _really_
+    // wanted 2AM. The problem is that time simply doesn't exist.
+    //
+    // Why is this a problem? Well, consider a case where the DST
+    // shift happens *at midnight* and it goes back an hour. You think
+    // you have a date object for the next day, but when formatted it
+    // actually shows the previous day. A more likely scenario: buggy
+    // timezone data makes JS dates do this shift when it shouldn't,
+    // so using midnight at the time for date logic gives back the
+    // last day. See the time range of Sep 30 15:00 - Oct 1 1:00 for
+    // the AEST timezone when nodejs-mobile incorrectly gives you back
+    // a time an hour *before* you specified. Since this happens on
+    // Oct 1, doing `addMonths(September, 1)` still gives you back
+    // September. Issue here:
+    // https://github.com/JaneaSystems/nodejs-mobile/issues/251
+    //
+    // The fix is simple once you understand this. Always use the 12th
+    // hour of the day. That's it. There is no DST that shifts more
+    // than 12 hours (god let's hope not) so no matter how far DST has
+    // shifted backwards or forwards, doing date logic will stay
+    // within the day we want.
+
+    const [year, month, day] = value.split('-');
+    if (day != null) {
+      return new Date(parseInt(year), parseInt(month) - 1, parseInt(day), 12);
+    } else if (month != null) {
+      return new Date(parseInt(year), parseInt(month) - 1, 1, 12);
+    } else {
+      return new Date(parseInt(year), 0, 1, 12);
+    }
+  }
+  if (typeof value === 'number') {
+    return new Date(value);
+  }
+  return value;
+}
+
+export const parseDate = _parse;
+
+export function yearFromDate(date: DateLike): string {
+  return d.format(_parse(date), 'yyyy');
+}
+
+export function monthFromDate(date: DateLike): string {
+  return d.format(_parse(date), 'yyyy-MM');
+}
+
+export function weekFromDate(
+  date: DateLike,
+  firstDayOfWeekIdx: SyncedPrefs['firstDayOfWeekIdx'],
+): string {
+  const converted = parseInt(firstDayOfWeekIdx || '0') as Day;
+  return d.format(
+    _parse(d.startOfWeek(_parse(date), { weekStartsOn: converted })),
+    'yyyy-MM-dd',
+  );
+}
+
+export function firstDayOfMonth(date: DateLike): string {
+  return dayFromDate(d.startOfMonth(_parse(date)));
+}
+
+export function lastDayOfMonth(date: DateLike): string {
+  return dayFromDate(d.endOfMonth(_parse(date)));
+}
+
+export function dayFromDate(date: DateLike): string {
+  return d.format(_parse(date), 'yyyy-MM-dd');
+}
+
+export function currentMonth(): string {
+  if (global.IS_TESTING || Platform.isPlaywright) {
+    return global.currentMonth || '2017-01';
+  } else {
+    return d.format(new Date(), 'yyyy-MM');
+  }
+}
+
+export function currentWeek(
+  firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx'],
+): string {
+  if (global.IS_TESTING || Platform.isPlaywright) {
+    return global.currentWeek || '2017-01-01';
+  } else {
+    const converted = parseInt(firstDayOfWeekIdx || '0') as Day;
+    return d.format(
+      _parse(d.startOfWeek(new Date(), { weekStartsOn: converted })),
+      'yyyy-MM-dd',
+    );
+  }
+}
+
+export function currentYear(): string {
+  if (global.IS_TESTING || Platform.isPlaywright) {
+    return global.currentMonth || '2017';
+  } else {
+    return d.format(new Date(), 'yyyy');
+  }
+}
+
+export function currentDate(): Date {
+  if (global.IS_TESTING || Platform.isPlaywright) {
+    return d.parse(currentDay(), 'yyyy-MM-dd', new Date());
+  }
+
+  return new Date();
+}
+
+export function currentDay(): string {
+  if (global.IS_TESTING || Platform.isPlaywright) {
+    return '2017-01-01';
+  } else {
+    return d.format(new Date(), 'yyyy-MM-dd');
+  }
+}
+
+export function nextMonth(month: DateLike): string {
+  return d.format(d.addMonths(_parse(month), 1), 'yyyy-MM');
+}
+
+export function prevYear(month: DateLike, format = 'yyyy-MM'): string {
+  return d.format(d.subMonths(_parse(month), 12), format);
+}
+
+export function prevMonth(month: DateLike): string {
+  return d.format(d.subMonths(_parse(month), 1), 'yyyy-MM');
+}
+
+export function addYears(year: DateLike, n: number): string {
+  return d.format(d.addYears(_parse(year), n), 'yyyy');
+}
+
+export function addMonths(month: DateLike, n: number): string {
+  return d.format(d.addMonths(_parse(month), n), 'yyyy-MM');
+}
+
+export function addWeeks(date: DateLike, n: number): string {
+  return d.format(d.addWeeks(_parse(date), n), 'yyyy-MM-dd');
+}
+
+export function differenceInCalendarMonths(
+  month1: DateLike,
+  month2: DateLike,
+): number {
+  return d.differenceInCalendarMonths(_parse(month1), _parse(month2));
+}
+
+export function differenceInCalendarDays(
+  month1: DateLike,
+  month2: DateLike,
+): number {
+  return d.differenceInCalendarDays(_parse(month1), _parse(month2));
+}
+
+export function subMonths(month: string | Date, n: number) {
+  return d.format(d.subMonths(_parse(month), n), 'yyyy-MM');
+}
+
+export function subWeeks(date: DateLike, n: number): string {
+  return d.format(d.subWeeks(_parse(date), n), 'yyyy-MM-dd');
+}
+
+export function subYears(year: string | Date, n: number) {
+  return d.format(d.subYears(_parse(year), n), 'yyyy');
+}
+
+export function addDays(day: DateLike, n: number): string {
+  return d.format(d.addDays(_parse(day), n), 'yyyy-MM-dd');
+}
+
+export function subDays(day: DateLike, n: number): string {
+  return d.format(d.subDays(_parse(day), n), 'yyyy-MM-dd');
+}
+
+export function isBefore(month1: DateLike, month2: DateLike): boolean {
+  return d.isBefore(_parse(month1), _parse(month2));
+}
+
+export function isAfter(month1: DateLike, month2: DateLike): boolean {
+  return d.isAfter(_parse(month1), _parse(month2));
+}
+
+export function isCurrentMonth(month: DateLike): boolean {
+  return month === currentMonth();
+}
+
+export function isCurrentDay(day: DateLike): boolean {
+  return day === currentDay();
+}
+
+// TODO: This doesn't really fit in this module anymore, should
+// probably live elsewhere
+export function bounds(month: DateLike): { start: number; end: number } {
+  return {
+    start: parseInt(d.format(d.startOfMonth(_parse(month)), 'yyyyMMdd')),
+    end: parseInt(d.format(d.endOfMonth(_parse(month)), 'yyyyMMdd')),
+  };
+}
+
+export function _yearRange(
+  start: DateLike,
+  end: DateLike,
+  inclusive = false,
+): string[] {
+  const years: string[] = [];
+  let year = yearFromDate(start);
+  const endYear = yearFromDate(end);
+  while (d.isBefore(_parse(year), _parse(endYear))) {
+    years.push(year);
+    year = addYears(year, 1);
+  }
+
+  if (inclusive) {
+    years.push(year);
+  }
+
+  return years;
+}
+
+export function yearRangeInclusive(start: DateLike, end: DateLike): string[] {
+  return _yearRange(start, end, true);
+}
+
+export function _weekRange(
+  start: DateLike,
+  end: DateLike,
+  inclusive = false,
+  firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx'],
+): string[] {
+  const weeks: string[] = [];
+  let week = weekFromDate(start, firstDayOfWeekIdx);
+  const endWeek = weekFromDate(end, firstDayOfWeekIdx);
+  while (d.isBefore(_parse(week), _parse(endWeek))) {
+    weeks.push(week);
+    week = addWeeks(week, 1);
+  }
+
+  if (inclusive) {
+    weeks.push(week);
+  }
+
+  return weeks;
+}
+
+export function weekRangeInclusive(
+  start: DateLike,
+  end: DateLike,
+  firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx'],
+): string[] {
+  return _weekRange(start, end, true, firstDayOfWeekIdx);
+}
+
+export function _range(
+  start: DateLike,
+  end: DateLike,
+  inclusive = false,
+): string[] {
+  const months: string[] = [];
+  let month = monthFromDate(start);
+  const endMonth = monthFromDate(end);
+  while (d.isBefore(_parse(month), _parse(endMonth))) {
+    months.push(month);
+    month = addMonths(month, 1);
+  }
+
+  if (inclusive) {
+    months.push(month);
+  }
+
+  return months;
+}
+
+export function range(start: DateLike, end: DateLike): string[] {
+  return _range(start, end);
+}
+
+export function rangeInclusive(start: DateLike, end: DateLike): string[] {
+  return _range(start, end, true);
+}
+
+export function _dayRange(
+  start: DateLike,
+  end: DateLike,
+  inclusive = false,
+): string[] {
+  const days: string[] = [];
+  let day = start;
+  while (d.isBefore(_parse(day), _parse(end))) {
+    days.push(dayFromDate(day));
+    day = addDays(day, 1);
+  }
+
+  if (inclusive) {
+    days.push(dayFromDate(day));
+  }
+
+  return days;
+}
+
+export function dayRange(start: DateLike, end: DateLike) {
+  return _dayRange(start, end);
+}
+
+export function dayRangeInclusive(start: DateLike, end: DateLike) {
+  return _dayRange(start, end, true);
+}
+
+export function getMonthFromIndex(year: string, monthIndex: number) {
+  const formatMonth = `${monthIndex + 1}`.padStart(2, '0');
+  return `${year}-${formatMonth}`;
+}
+
+export function getMonthIndex(month: string): number {
+  return parseInt(month.slice(5, 7)) - 1;
+}
+
+export function getYear(month: string): string {
+  return month.slice(0, 4);
+}
+
+export function getMonth(day: string): string {
+  return day.slice(0, 7);
+}
+
+export function getDay(day: string): number {
+  return Number(d.format(_parse(day), 'dd'));
+}
+
+export function getMonthEnd(day: string): string {
+  return subDays(nextMonth(day.slice(0, 7)) + '-01', 1);
+}
+
+export function getWeekEnd(
+  date: DateLike,
+  firstDayOfWeekIdx?: SyncedPrefs['firstDayOfWeekIdx'],
+): string {
+  const converted = parseInt(firstDayOfWeekIdx || '0') as Day;
+  return d.format(
+    _parse(d.endOfWeek(_parse(date), { weekStartsOn: converted })),
+    'yyyy-MM-dd',
+  );
+}
+
+export function getYearStart(month: string): string {
+  return getYear(month) + '-01';
+}
+
+export function getYearEnd(month: string): string {
+  return getYear(month) + '-12';
+}
+
+export function sheetForMonth(month: string): string {
+  return 'budget' + month.replace('-', '');
+}
+
+export function nameForMonth(month: DateLike, locale?: Locale): string {
+  return d.format(_parse(month), "MMMM ''yy", { locale });
+}
+
+export function format(
+  month: DateLike,
+  format: string,
+  locale?: Locale,
+): string {
+  return d.format(_parse(month), format, { locale });
+}
+
+export function formatDistance(
+  date1: DateLike,
+  date2: DateLike,
+  locale?: Locale,
+  options?: { addSuffix?: boolean; includeSeconds?: boolean },
+): string {
+  return d.formatDistance(_parse(date1), _parse(date2), {
+    locale,
+    ...options,
+  });
+}
+
+export const getDateFormatRegex = memoizeOne((format: string) => {
+  return new RegExp(
+    format
+      .replace(/d+/g, '\\d{1,2}')
+      .replace(/M+/g, '\\d{1,2}')
+      .replace(/y+/g, '\\d{4}'),
+  );
+});
+
+export const getDayMonthFormat = memoizeOne((format: string) => {
+  return format
+    .replace(/y+/g, '')
+    .replace(/[^\w]$/, '')
+    .replace(/^[^\w]/, '');
+});
+
+export const getDayMonthRegex = memoizeOne((format: string) => {
+  const regex = format
+    .replace(/y+/g, '')
+    .replace(/[^\w]$/, '')
+    .replace(/^[^\w]/, '')
+    .replace(/d+/g, '\\d{1,2}')
+    .replace(/M+/g, '\\d{1,2}');
+  return new RegExp('^' + regex + '$');
+});
+
+export const getMonthYearFormat = memoizeOne((format: string) => {
+  return format
+    .replace(/d+/g, '')
+    .replace(/[^\w]$/, '')
+    .replace(/^[^\w]/, '')
+    .replace(/\/\//, '/')
+    .replace(/\.\./, '.')
+    .replace(/--/, '-');
+});
+
+export const getMonthYearRegex = memoizeOne((format: string) => {
+  const regex = format
+    .replace(/d+/g, '')
+    .replace(/[^\w]$/, '')
+    .replace(/^[^\w]/, '')
+    .replace(/\/\//, '/')
+    .replace(/M+/g, '\\d{1,2}')
+    .replace(/y+/g, '\\d{2,4}');
+  return new RegExp('^' + regex + '$');
+});
+
+export const getShortYearFormat = memoizeOne((format: string) => {
+  return format.replace(/y+/g, 'yy');
+});
+
+export const getShortYearRegex = memoizeOne((format: string) => {
+  const regex = format
+    .replace(/[^\w]$/, '')
+    .replace(/^[^\w]/, '')
+    .replace(/d+/g, '\\d{1,2}')
+    .replace(/M+/g, '\\d{1,2}')
+    .replace(/y+/g, '\\d{2}');
+  return new RegExp('^' + regex + '$');
+});

package/src/shared/normalisation.ts

@@ -0,0 +1,6 @@
+export function getNormalisedString(value: string) {
+  return value
+    .toLowerCase()
+    .normalize('NFD')
+    .replace(/\p{Diacritic}/gu, '');
+}

package/src/shared/platform.electron.ts

@@ -0,0 +1,21 @@
+import os from 'os';
+
+import type * as T from './platform';
+
+const isWindows = os.platform() === 'win32';
+const isMac = os.platform() === 'darwin';
+const isLinux = os.platform() === 'linux';
+
+export const isPlaywright = false;
+
+export const OS: typeof T.OS = isWindows
+  ? 'windows'
+  : isMac
+    ? 'mac'
+    : isLinux
+      ? 'linux'
+      : 'unknown';
+export const env: typeof T.env = 'unknown';
+export const isBrowser: typeof T.isBrowser = false;
+
+export const isIOSAgent: typeof T.isIOSAgent = false;

package/src/shared/platform.ts

@@ -0,0 +1,20 @@
+import { UAParser } from 'ua-parser-js';
+
+const isWindows =
+  navigator.platform && navigator.platform.toLowerCase() === 'win32';
+
+const isMac =
+  navigator.platform && navigator.platform.toUpperCase().indexOf('MAC') >= 0;
+
+export const isPlaywright = navigator.userAgent === 'playwright';
+
+export const OS: 'windows' | 'mac' | 'linux' | 'unknown' = isWindows
+  ? 'windows'
+  : isMac
+    ? 'mac'
+    : 'linux';
+export const env: 'web' | 'mobile' | 'unknown' = 'web';
+export const isBrowser: boolean = true;
+
+const agent = UAParser(navigator.userAgent);
+export const isIOSAgent = agent.browser.name === 'Mobile Safari';

package/src/shared/query.ts

@@ -0,0 +1,176 @@
+import type { WithRequired } from '../types/util';
+
+type ObjectExpression = {
+  [key: string]: ObjectExpression | unknown;
+};
+
+export type QueryState = {
+  get table(): string;
+  get tableOptions(): Readonly<Record<string, unknown>>;
+  get filterExpressions(): ReadonlyArray<ObjectExpression>;
+  get selectExpressions(): ReadonlyArray<ObjectExpression | string | '*'>;
+  get groupExpressions(): ReadonlyArray<ObjectExpression | string>;
+  get orderExpressions(): ReadonlyArray<ObjectExpression | string>;
+  get calculation(): boolean;
+  get rawMode(): boolean;
+  get withDead(): boolean;
+  get validateRefs(): boolean;
+  get limit(): number | null;
+  get offset(): number | null;
+};
+
+export class Query {
+  state: QueryState;
+
+  constructor(state: WithRequired<Partial<QueryState>, 'table'>) {
+    this.state = {
+      tableOptions: state.tableOptions || {},
+      filterExpressions: state.filterExpressions || [],
+      selectExpressions: state.selectExpressions || [],
+      groupExpressions: state.groupExpressions || [],
+      orderExpressions: state.orderExpressions || [],
+      calculation: false,
+      rawMode: false,
+      withDead: false,
+      validateRefs: true,
+      limit: null,
+      offset: null,
+      ...state,
+    };
+  }
+
+  filter(expr: ObjectExpression) {
+    return new Query({
+      ...this.state,
+      filterExpressions: [...this.state.filterExpressions, expr],
+    });
+  }
+
+  unfilter(exprs?: Array<keyof ObjectExpression>) {
+    // Remove all filters if no arguments are passed
+    if (!exprs) {
+      return new Query({
+        ...this.state,
+        filterExpressions: [],
+      });
+    }
+
+    const exprSet = new Set(exprs);
+    return new Query({
+      ...this.state,
+      filterExpressions: this.state.filterExpressions.filter(
+        expr => !exprSet.has(Object.keys(expr)[0]),
+      ),
+    });
+  }
+
+  select(
+    exprs:
+      | Array<ObjectExpression | string>
+      | ObjectExpression
+      | string
+      | '*'
+      | ['*'] = [],
+  ) {
+    if (!Array.isArray(exprs)) {
+      exprs = [exprs];
+    }
+
+    return new Query({
+      ...this.state,
+      selectExpressions: exprs,
+      calculation: false,
+    });
+  }
+
+  calculate(expr: ObjectExpression | string) {
+    return new Query({
+      ...this.state,
+      selectExpressions: [{ result: expr }],
+      calculation: true,
+    });
+  }
+
+  groupBy(exprs: ObjectExpression | string | Array<ObjectExpression | string>) {
+    if (!Array.isArray(exprs)) {
+      exprs = [exprs];
+    }
+
+    return new Query({
+      ...this.state,
+      groupExpressions: [...this.state.groupExpressions, ...exprs],
+    });
+  }
+
+  orderBy(exprs: ObjectExpression | string | Array<ObjectExpression | string>) {
+    if (!Array.isArray(exprs)) {
+      exprs = [exprs];
+    }
+
+    return new Query({
+      ...this.state,
+      orderExpressions: [...this.state.orderExpressions, ...exprs],
+    });
+  }
+
+  limit(num: number) {
+    return new Query({ ...this.state, limit: num });
+  }
+
+  offset(num: number) {
+    return new Query({ ...this.state, offset: num });
+  }
+
+  raw() {
+    return new Query({ ...this.state, rawMode: true });
+  }
+
+  withDead() {
+    return new Query({ ...this.state, withDead: true });
+  }
+
+  withoutValidatedRefs() {
+    return new Query({ ...this.state, validateRefs: false });
+  }
+
+  options(opts: Record<string, unknown>) {
+    return new Query({ ...this.state, tableOptions: opts });
+  }
+
+  reset() {
+    return q(this.state.table);
+  }
+
+  serialize() {
+    return this.state;
+  }
+
+  serializeAsString() {
+    return JSON.stringify(this.serialize());
+  }
+}
+
+export function getPrimaryOrderBy(
+  query: Query,
+  defaultOrderBy: ObjectExpression | null,
+) {
+  const orderExprs = query.serialize().orderExpressions;
+  if (orderExprs.length === 0) {
+    if (defaultOrderBy) {
+      return { order: 'asc', ...defaultOrderBy };
+    }
+    return null;
+  }
+
+  const firstOrder = orderExprs[0];
+  if (typeof firstOrder === 'string') {
+    return { field: firstOrder, order: 'asc' };
+  }
+  // Handle this form: { field: 'desc' }
+  const [field] = Object.keys(firstOrder);
+  return { field, order: firstOrder[field] };
+}
+
+export function q(table: QueryState['table']) {
+  return new Query({ table });
+}