@actual-app/core 26.3.0

package/src/server/util/budget-name.ts

@@ -0,0 +1,61 @@
+import { v4 as uuidv4 } from 'uuid';
+
+import * as fs from '../../platform/server/fs';
+import { handlers } from '../main';
+
+export async function uniqueBudgetName(
+  initialName: string = 'My Finances',
+): Promise<string> {
+  const budgets = await handlers['get-budgets']();
+  let idx = 1;
+
+  // If there is a conflict, keep appending an index until there is no
+  // conflict and we have a unique name
+  let newName = initialName;
+  while (budgets.find(file => file.name === newName)) {
+    newName = `${initialName} ${idx}`;
+    idx++;
+  }
+
+  return newName;
+}
+
+export async function validateBudgetName(
+  name: string,
+): Promise<{ valid: boolean; message?: string }> {
+  const trimmedName = name.trim();
+  const uniqueName = await uniqueBudgetName(trimmedName);
+  let message: string | null = null;
+
+  if (trimmedName === '') message = 'Budget name cannot be blank';
+  if (trimmedName.length > 100) {
+    message = 'Budget name is too long (max length 100)';
+  }
+  if (uniqueName !== trimmedName) {
+    message = `"${name}" already exists, try "${uniqueName}" instead`;
+  }
+
+  return message ? { valid: false, message } : { valid: true };
+}
+
+export async function idFromBudgetName(name: string): Promise<string> {
+  let id = name.replace(/( |[^A-Za-z0-9])/g, '-') + '-' + uuidv4().slice(0, 7);
+
+  // Make sure the id is unique. There's a chance one could already
+  // exist (although very unlikely now that we append unique
+  // characters onto the id)
+  let index = 0;
+
+  let budgetDir = fs.getBudgetDir(id);
+  while (await fs.exists(budgetDir)) {
+    index++;
+    budgetDir = fs.getBudgetDir(id + index.toString());
+  }
+
+  // If a suffix was added, update the id
+  if (index > 0) {
+    id = id + index.toString();
+  }
+
+  return id;
+}

package/src/server/util/custom-sync-mapping.ts

@@ -0,0 +1,48 @@
+export type Mappings = Map<string, Map<string, string>>;
+
+export const mappingsToString = (mapping: Mappings): string =>
+  JSON.stringify(
+    Object.fromEntries(
+      [...mapping.entries()].map(([key, value]) => [
+        key,
+        Object.fromEntries(value),
+      ]),
+    ),
+  );
+
+export const mappingsFromString = (str: string): Mappings => {
+  try {
+    const parsed = JSON.parse(str);
+    if (typeof parsed !== 'object' || parsed === null) {
+      throw new Error('Invalid mapping format');
+    }
+    return new Map(
+      Object.entries(parsed).map(([key, value]) => [
+        key,
+        new Map(Object.entries(value as object)),
+      ]),
+    );
+  } catch (e) {
+    const message = e instanceof Error ? e.message : e;
+    throw new Error(`Failed to parse mapping: ${String(message)}`);
+  }
+};
+
+export const defaultMappings: Mappings = new Map([
+  [
+    'payment',
+    new Map([
+      ['date', 'date'],
+      ['payee', 'payeeName'],
+      ['notes', 'notes'],
+    ]),
+  ],
+  [
+    'deposit',
+    new Map([
+      ['date', 'date'],
+      ['payee', 'payeeName'],
+      ['notes', 'notes'],
+    ]),
+  ],
+]);

package/src/server/util/rschedule.ts

@@ -0,0 +1,9 @@
+import '@rschedule/standard-date-adapter/setup';
+import { Schedule as OriginalSchedule } from '@rschedule/core/generators';
+
+export * from '@rschedule/standard-date-adapter';
+export * from '@rschedule/core';
+export * from '@rschedule/core/generators';
+
+// Creates a wrapper class to ensure constructor behavior when bundled with vite
+export class RSchedule extends OriginalSchedule {}

package/src/shared/__mocks__/platform.ts

@@ -0,0 +1,7 @@
+export const isPlaywright = false;
+
+export const OS: 'windows' | 'mac' | 'linux' | 'unknown' = 'unknown';
+export const env: 'web' | 'mobile' | 'unknown' = 'unknown';
+export const isBrowser = false;
+
+export const isIOSAgent = false;

package/src/shared/__snapshots__/months.test.ts.snap

@@ -0,0 +1,21 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`range returns a full range 1`] = `
+[
+  "2016-10",
+  "2016-11",
+  "2016-12",
+  "2017-01",
+  "2017-02",
+  "2017-03",
+  "2017-04",
+  "2017-05",
+  "2017-06",
+  "2017-07",
+  "2017-08",
+  "2017-09",
+  "2017-10",
+  "2017-11",
+  "2017-12",
+]
+`;

package/src/shared/arithmetic.test.ts

@@ -0,0 +1,112 @@
+import { evalArithmetic } from './arithmetic';
+import { setNumberFormat } from './util';
+
+describe('arithmetic', () => {
+  test('handles negative numbers', () => {
+    expect(evalArithmetic('-4')).toBe(-4);
+    expect(evalArithmetic('10 + -4')).toBe(6);
+  });
+
+  test('handles simple addition', () => {
+    expect(evalArithmetic('10 + 10')).toEqual(20);
+    expect(evalArithmetic('1.5 + 1.5')).toEqual(3);
+    expect(evalArithmetic('(12 + 3) + (10)')).toEqual(25);
+    expect(evalArithmetic('10 + 20 + 30 + 40')).toEqual(100);
+  });
+
+  test('handles simple subtraction', () => {
+    expect(evalArithmetic('10 - 10')).toEqual(0);
+    expect(evalArithmetic('4.5 - 1.5')).toEqual(3);
+    expect(evalArithmetic('(12 - 3) - (10)')).toEqual(-1);
+    expect(evalArithmetic('10 - 20 - 30 - 40')).toEqual(-80);
+  });
+
+  test('handles multiplication', () => {
+    expect(evalArithmetic('10 * 10')).toEqual(100);
+    expect(evalArithmetic('1.5 * 1.5')).toEqual(2.25);
+    expect(evalArithmetic('10 * 20 * 30 * 40')).toEqual(240000);
+  });
+
+  test('handles division', () => {
+    expect(evalArithmetic('10 / 10')).toEqual(1);
+    expect(evalArithmetic('1.5 / .5')).toEqual(3);
+    expect(evalArithmetic('2400 / 2 / 5')).toEqual(240);
+  });
+
+  test('handles order of operations', () => {
+    expect(evalArithmetic('(5 + 3) * 10')).toEqual(80);
+    expect(evalArithmetic('5 + 3 * 10')).toEqual(35);
+    expect(evalArithmetic('20^3 - 5 * (10 / 2)')).toEqual(7975);
+  });
+
+  test('handles exponent as right-associative', () => {
+    expect(evalArithmetic('2^3^2')).toEqual(512);
+  });
+
+  test('handles same-precedence operators left-to-right', () => {
+    expect(evalArithmetic('24 / 3 * 2')).toEqual(16);
+    expect(evalArithmetic('24 * 3 / 2')).toEqual(36);
+    expect(evalArithmetic('10 - 2 + 1')).toEqual(9);
+    expect(evalArithmetic('10 + 2 - 1')).toEqual(11);
+  });
+
+  test('respects current number format', () => {
+    expect(evalArithmetic('1,222.45')).toEqual(1222.45);
+
+    setNumberFormat({ format: 'space-comma', hideFraction: false });
+    expect(evalArithmetic('1\u202F222,45')).toEqual(1222.45);
+
+    setNumberFormat({ format: 'apostrophe-dot', hideFraction: false });
+    expect(evalArithmetic(`1\u2019222.45`)).toEqual(1222.45);
+  });
+
+  test('ignores leftover characters', () => {
+    expect(evalArithmetic('1+2)')).toBe(3);
+    expect(evalArithmetic('1+2)foo')).toBe(3);
+    expect(evalArithmetic('(1+2)x')).toBe(3);
+    expect(evalArithmetic('10+20 trailing')).toBe(30);
+    expect(evalArithmetic('1+2(3')).toBe(3);
+  });
+
+  test('handles apostrophe-dot format with keyboard apostrophe (U+0027)', () => {
+    setNumberFormat({ format: 'apostrophe-dot', hideFraction: false });
+
+    // Test with keyboard apostrophe (U+0027) - what users type
+    const keyboardApostrophe = '12\u0027345.67';
+    expect(keyboardApostrophe.charCodeAt(2)).toBe(0x0027); // Verify it's U+0027
+    expect(evalArithmetic(keyboardApostrophe)).toBe(12345.67);
+
+    // More test cases with keyboard apostrophe
+    expect(evalArithmetic('1\u0027234.56')).toBe(1234.56);
+    expect(evalArithmetic('1\u0027000.33')).toBe(1000.33);
+    expect(evalArithmetic('100\u0027000.99')).toBe(100000.99);
+    expect(evalArithmetic('1\u0027000\u0027000.50')).toBe(1000000.5);
+  });
+
+  test('handles apostrophe-dot format with typographic apostrophe (U+2019)', () => {
+    setNumberFormat({ format: 'apostrophe-dot', hideFraction: false });
+
+    // Test with right single quotation mark (U+2019) - what Intl.NumberFormat outputs
+    const intlApostrophe = '12\u2019345.67';
+    expect(intlApostrophe.charCodeAt(2)).toBe(0x2019); // Verify it's U+2019
+    expect(evalArithmetic(intlApostrophe)).toBe(12345.67);
+
+    // More test cases with typographic apostrophe
+    expect(evalArithmetic('1\u2019234.56')).toBe(1234.56);
+    expect(evalArithmetic('1\u2019000.33')).toBe(1000.33);
+  });
+
+  test('handles apostrophe-dot format in arithmetic expressions', () => {
+    setNumberFormat({ format: 'apostrophe-dot', hideFraction: false });
+
+    // Test arithmetic operations with keyboard apostrophe
+    expect(evalArithmetic('1\u0027000 + 2\u0027000')).toBe(3000);
+    expect(evalArithmetic('10\u0027000 - 2\u0027500')).toBe(7500);
+    expect(evalArithmetic('1\u0027000 * 2')).toBe(2000);
+    expect(evalArithmetic('4\u0027000 / 2')).toBe(2000);
+
+    // Test arithmetic operations with typographic apostrophe
+    expect(evalArithmetic('1\u2019000 + 2\u2019000')).toBe(3000);
+    expect(evalArithmetic('10\u2019000 - 2\u2019500')).toBe(7500);
+  });
+});

package/src/shared/arithmetic.ts

@@ -0,0 +1,170 @@
+import { currencyToAmount } from './util';
+
+type ParserState = {
+  str: string;
+  index: number;
+};
+
+type Operator = '+' | '-' | '*' | '/' | '^';
+
+type OperatorNode = {
+  op: Operator;
+  left: AstNode;
+  right: AstNode;
+};
+
+type AstNode = number | OperatorNode;
+
+function fail(state: ParserState, msg: string): never {
+  throw new Error(
+    msg + ': ' + JSON.stringify(state.str.slice(state.index, 10)),
+  );
+}
+
+function char(state: ParserState): string | undefined {
+  return state.str[state.index];
+}
+
+function next(state: ParserState): string | null {
+  if (state.index >= state.str.length) {
+    return null;
+  }
+
+  const ch = char(state);
+  state.index++;
+  return ch ?? null;
+}
+
+function nextOperator(state: ParserState, op: string): boolean {
+  if (char(state) === op) {
+    next(state);
+    return true;
+  }
+
+  return false;
+}
+
+function parsePrimary(state: ParserState): number {
+  // We only support numbers
+  const isNegative = char(state) === '-';
+  if (isNegative) {
+    next(state);
+  }
+
+  let numberStr = '';
+  let currentChar = char(state);
+  while (
+    currentChar &&
+    currentChar.match(/[0-9,.'\u2019\u00A0\u202F ]|\p{Sc}/u)
+  ) {
+    const ch = next(state);
+    if (ch !== null) {
+      numberStr += ch;
+    }
+    currentChar = char(state);
+  }
+
+  if (numberStr === '') {
+    fail(state, 'Unexpected character');
+  }
+
+  const number = currencyToAmount(numberStr);
+  if (number === null) {
+    fail(state, 'Invalid number format');
+  }
+  return isNegative ? -number : number;
+}
+
+function parseParens(state: ParserState): AstNode {
+  if (char(state) === '(') {
+    next(state);
+    const expr = parseOperator(state);
+
+    if (char(state) !== ')') {
+      fail(state, 'Unbalanced parentheses');
+    }
+
+    next(state);
+    return expr;
+  }
+
+  return parsePrimary(state);
+}
+
+function parseExponent(state: ParserState): AstNode {
+  let node = parseParens(state);
+  if (nextOperator(state, '^')) {
+    node = { op: '^', left: node, right: parseExponent(state) };
+  }
+  return node;
+}
+
+function parseMultiplicative(state: ParserState): AstNode {
+  let node = parseExponent(state);
+  while (char(state) === '*' || char(state) === '/') {
+    const op = next(state) as '*' | '/';
+    node = { op, left: node, right: parseExponent(state) };
+  }
+  return node;
+}
+
+function parseAdditive(state: ParserState): AstNode {
+  let node = parseMultiplicative(state);
+  while (char(state) === '+' || char(state) === '-') {
+    const op = next(state) as '+' | '-';
+    node = { op, left: node, right: parseMultiplicative(state) };
+  }
+  return node;
+}
+
+// These operators go from high to low order of precedence
+const parseOperator = parseAdditive;
+
+function parse(expression: string): AstNode {
+  const state = { str: expression.replace(/\s/g, ''), index: 0 };
+  return parseOperator(state);
+}
+
+function evaluate(ast: AstNode): number {
+  if (typeof ast === 'number') {
+    return ast;
+  }
+
+  const { left, right, op } = ast;
+
+  switch (op) {
+    case '+':
+      return evaluate(left) + evaluate(right);
+    case '-':
+      return evaluate(left) - evaluate(right);
+    case '*':
+      return evaluate(left) * evaluate(right);
+    case '/':
+      return evaluate(left) / evaluate(right);
+    case '^':
+      return Math.pow(evaluate(left), evaluate(right));
+    default:
+      throw new Error('Unknown operator: ' + op);
+  }
+}
+
+export function evalArithmetic(
+  expression: string,
+  defaultValue: number | null = null,
+): number | null {
+  // An empty expression always evals to the default
+  if (expression === '') {
+    return defaultValue;
+  }
+
+  let result: number;
+  try {
+    result = evaluate(parse(expression));
+  } catch {
+    // If it errors, return the default value
+    return defaultValue;
+  }
+
+  // Never return NaN
+  return isNaN(result) ? defaultValue : result;
+}

package/src/shared/async.test.ts

@@ -0,0 +1,135 @@
+// @ts-strict-ignore
+import { once, sequential } from './async';
+
+function timeout(n) {
+  return new Promise(resolve => setTimeout(resolve, n));
+}
+
+function makeFunction(data) {
+  return async function fn(n, { throwError = false } = {}) {
+    data.push(n);
+    await timeout(10);
+
+    if (throwError) {
+      throw new Error('throwing error');
+    }
+
+    data.push(n);
+    await timeout(50);
+    data.push(n);
+  };
+}
+
+describe('async', () => {
+  test('sequential fn should force concurrent calls to be in order', async () => {
+    const test = async fn => {
+      fn(1);
+      fn(2);
+      await fn(3);
+    };
+
+    const data = [];
+    await test(makeFunction(data));
+    expect(data).toEqual([1, 2, 3, 1, 2, 3, 1, 2, 3]);
+
+    const seqData = [];
+    await test(sequential(makeFunction(seqData)));
+    expect(seqData).toEqual([1, 1, 1, 2, 2, 2, 3, 3, 3]);
+
+    expect(data.length).toEqual(seqData.length);
+  });
+
+  test('sequential fn should always call function when queue is empty', async () => {
+    const test = async fn => {
+      await fn(1);
+      await fn(2);
+      await fn(3);
+    };
+
+    const data = [];
+    await test(makeFunction(data));
+    expect(data).toEqual([1, 1, 1, 2, 2, 2, 3, 3, 3]);
+
+    const seqData = [];
+    await test(sequential(makeFunction(seqData)));
+    expect(seqData).toEqual([1, 1, 1, 2, 2, 2, 3, 3, 3]);
+
+    expect(data.length).toEqual(seqData.length);
+  });
+
+  test('sequential fn should still flush queue when error is thrown', async () => {
+    const test = async fn => {
+      fn(1);
+      fn(2, { throwError: true }).catch(() => {
+        // Ignore errors
+      });
+      await fn(3);
+    };
+
+    const data = [];
+    await test(makeFunction(data));
+    expect(data).toEqual([1, 2, 3, 1, 3, 1, 3]);
+
+    const seqData = [];
+    await test(sequential(makeFunction(seqData)));
+    expect(seqData).toEqual([1, 1, 1, 2, 3, 3, 3]);
+
+    expect(data.length).toEqual(seqData.length);
+  });
+
+  test('sequential fn should ignore promise chains in the future', async () => {
+    const data = [];
+    const fn = sequential(makeFunction(data));
+
+    void fn(1).then(() => {
+      // The next call should already have started (so it should have
+      // already appended 2 to the end). It shouldn't depend on this
+      // promise chain at all (important part being that if any errors
+      // happened in here, it wouldn't effect anything else)
+      expect(data).toEqual([1, 1, 1, 2]);
+    });
+    fn(2, { throwError: true }).catch(() => {
+      // Same as above
+      expect(data).toEqual([1, 1, 1, 2, 3]);
+    });
+    await fn(3);
+
+    expect(data).toEqual([1, 1, 1, 2, 3, 3, 3]);
+  });
+
+  test('once fn should only be called once', async () => {
+    let timesCalled = 0;
+    const fn = once(async () => {
+      await timeout(200);
+      timesCalled++;
+    });
+
+    await Promise.all([fn(), fn(), fn()]);
+
+    // It should only have been called once
+    expect(timesCalled).toBe(1);
+
+    // Make sure it's called again now that it's done executing
+    await Promise.all([fn(), fn()]);
+    expect(timesCalled).toBe(2);
+  });
+
+  test('once fn should coalesce multiple calls', async () => {
+    let timesCalled = 0;
+    const fn = once(async () => {
+      await timeout(200);
+      timesCalled++;
+      return {};
+    });
+
+    const results = await Promise.all([fn(), fn(), fn()]);
+
+    // It should only have been called once
+    expect(timesCalled).toBe(1);
+
+    // The results should all be identical (`toBe` is a strict
+    // comparison, like ===)
+    expect(results[0]).toBe(results[1]);
+    expect(results[0]).toBe(results[2]);
+  });
+});

package/src/shared/async.ts

@@ -0,0 +1,76 @@
+// oxlint-disable-next-line typescript/no-explicit-any
+type AnyFunction = (...args: any[]) => any;
+
+export function sequential<T extends AnyFunction>(
+  fn: T,
+): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>> {
+  const sequenceState: {
+    running: Promise<Awaited<ReturnType<T>>> | null;
+    queue: Array<{
+      args: Parameters<T>;
+      resolve: (
+        value: Awaited<ReturnType<T>> | PromiseLike<Awaited<ReturnType<T>>>,
+      ) => void;
+      reject: (reason?: unknown) => void;
+    }>;
+  } = {
+    running: null,
+    queue: [],
+  };
+
+  function pump() {
+    const next = sequenceState.queue.shift();
+    if (next !== undefined) {
+      run(next.args, next.resolve, next.reject);
+    } else {
+      sequenceState.running = null;
+    }
+  }
+
+  function run(
+    args: Parameters<T>,
+    resolve: (
+      value: Awaited<ReturnType<T>> | PromiseLike<Awaited<ReturnType<T>>>,
+    ) => void,
+    reject: (reason?: unknown) => void,
+  ) {
+    sequenceState.running = fn.apply(null, args).then(
+      (val: Awaited<ReturnType<T>> | PromiseLike<Awaited<ReturnType<T>>>) => {
+        pump();
+        resolve(val);
+      },
+      (err: unknown) => {
+        pump();
+        reject(err);
+      },
+    );
+  }
+
+  return ((...args: Parameters<T>) => {
+    if (!sequenceState.running) {
+      return new Promise<Awaited<ReturnType<T>>>((resolve, reject) => {
+        return run(args, resolve, reject);
+      });
+    } else {
+      return new Promise<Awaited<ReturnType<T>>>((resolve, reject) => {
+        sequenceState.queue.push({ resolve, reject, args });
+      });
+    }
+  }) as T;
+}
+
+export function once<T extends AnyFunction>(
+  fn: T,
+): (...args: Parameters<T>) => Promise<Awaited<ReturnType<T>>> | null {
+  let promise: Promise<Awaited<ReturnType<T>>> | null = null;
+  return (...args: Parameters<T>) => {
+    if (!promise) {
+      promise = fn.apply(null, args).finally(() => {
+        promise = null;
+      });
+      return promise;
+    }
+
+    return promise;
+  };
+}

package/src/shared/constants.ts

@@ -0,0 +1,5 @@
+/**
+ * Default maximum distance (in meters) for nearby payee lookups.
+ * Payees with locations beyond this distance are not considered "nearby".
+ */
+export const DEFAULT_MAX_DISTANCE_METERS = 500;