mulmoclaude 0.9.0 → 0.9.2

package/src/plugins/accounting/components/OpeningBalancesForm.vue

@@ -1,272 +0,0 @@
-<template>
-  <form class="flex flex-col gap-3" data-testid="accounting-opening-form" @submit.prevent="onSubmit">
-    <div class="flex items-center justify-between gap-2">
-      <h3 class="text-base font-semibold">{{ t("pluginAccounting.openingForm.title") }}</h3>
-      <button
-        type="button"
-        class="h-8 px-2.5 flex items-center gap-1 rounded border border-gray-300 text-sm text-gray-600 hover:bg-gray-50"
-        data-testid="accounting-opening-manage-accounts"
-        @click="showAccountsModal = true"
-      >
-        <span class="material-icons text-base">tune</span>
-        <span>{{ t("pluginAccounting.accounts.manageButton") }}</span>
-      </button>
-    </div>
-    <p class="text-xs text-gray-500">{{ t("pluginAccounting.openingForm.explainer") }}</p>
-    <p class="text-xs text-blue-600" data-testid="accounting-opening-empty-hint">{{ t("pluginAccounting.openingForm.emptyHint") }}</p>
-    <div v-if="existing" class="text-xs text-gray-500" data-testid="accounting-opening-existing">
-      {{ t("pluginAccounting.openingForm.setBy", { date: existing.date }) }}
-      <span v-if="existing" class="text-amber-600 ml-2">{{ t("pluginAccounting.openingForm.replaceWarning") }}</span>
-    </div>
-    <p v-else class="text-xs text-gray-400" data-testid="accounting-opening-none">{{ t("pluginAccounting.openingForm.none") }}</p>
-    <label class="text-xs text-gray-500 flex flex-col gap-1 w-fit">
-      {{ t("pluginAccounting.openingForm.asOfLabel") }}
-      <input v-model="asOfDate" type="date" required class="h-8 px-2 rounded border border-gray-300 text-sm" data-testid="accounting-opening-asof" />
-    </label>
-    <table class="w-full text-sm">
-      <thead>
-        <tr class="text-xs text-gray-500 border-b border-gray-200">
-          <th class="text-left py-1 px-2">{{ t("pluginAccounting.entryForm.accountLabel") }}</th>
-          <th class="text-right py-1 px-2 w-32">{{ t("pluginAccounting.entryForm.debitLabel") }}</th>
-          <th class="text-right py-1 px-2 w-32">{{ t("pluginAccounting.entryForm.creditLabel") }}</th>
-        </tr>
-      </thead>
-      <tbody>
-        <tr v-for="account in bsAccounts" :key="account.code" class="border-b border-gray-100">
-          <td class="py-1 px-2">
-            <span class="font-mono text-[10px] text-gray-400 mr-2">{{ account.code }}</span>
-            <span>{{ account.name }}</span>
-            <span class="ml-2 text-xs text-gray-400">{{ account.type }}</span>
-          </td>
-          <td class="py-1 px-2">
-            <input
-              v-model.number="rows[account.code].debit"
-              type="number"
-              :step="step"
-              min="0"
-              class="h-8 px-2 w-full rounded border border-gray-300 text-sm text-right"
-              :data-testid="`accounting-opening-debit-${account.code}`"
-              @input="onDebitInput(account.code)"
-            />
-          </td>
-          <td class="py-1 px-2">
-            <input
-              v-model.number="rows[account.code].credit"
-              type="number"
-              :step="step"
-              min="0"
-              class="h-8 px-2 w-full rounded border border-gray-300 text-sm text-right"
-              :data-testid="`accounting-opening-credit-${account.code}`"
-              @input="onCreditInput(account.code)"
-            />
-          </td>
-        </tr>
-      </tbody>
-    </table>
-    <div class="flex items-center justify-between">
-      <span class="text-xs text-gray-400">{{ t("pluginAccounting.openingForm.explainer2") }}</span>
-      <span :class="balanced ? 'text-green-600' : 'text-red-500'" class="text-xs" data-testid="accounting-opening-balance">
-        {{ balanced ? t("pluginAccounting.entryForm.balanced") : t("pluginAccounting.entryForm.imbalance", { amount: imbalanceText }) }}
-      </span>
-    </div>
-    <p v-if="error" class="text-xs text-red-500" data-testid="accounting-opening-error">{{ error }}</p>
-    <p v-if="successMessage" class="text-xs text-green-600" data-testid="accounting-opening-success">{{ successMessage }}</p>
-    <div class="flex justify-end">
-      <button
-        type="submit"
-        class="h-8 px-3 rounded bg-blue-600 hover:bg-blue-700 text-white text-sm disabled:opacity-50"
-        :disabled="!balanced || submitting"
-        data-testid="accounting-opening-submit"
-      >
-        {{ submitting ? t("pluginAccounting.entryForm.submitting") : t("pluginAccounting.openingForm.submit") }}
-      </button>
-    </div>
-  </form>
-  <!-- Sibling of the parent <form> on purpose: the modal renders
-       its own <form @submit.prevent> for the inline editor, and
-       nesting <form>s is invalid HTML that breaks Enter-key submit
-       routing in some browsers. Vue 3 multi-root templates let us
-       keep the markup flat with no wrapper div. -->
-  <AccountsModal v-if="showAccountsModal" :book-id="bookId" :accounts="accounts" @close="showAccountsModal = false" />
-</template>
-
-<script setup lang="ts">
-import { computed, ref, watch } from "vue";
-import { useI18n } from "vue-i18n";
-import { getOpeningBalances, setOpeningBalances, type Account, type JournalEntry, type JournalLine } from "../api";
-import { formatAmount, inputStepFor } from "../currencies";
-import { localDateString } from "../dates";
-import { useLatestRequest } from "./useLatestRequest";
-import AccountsModal from "./AccountsModal.vue";
-import { errorMessage } from "../../../utils/errors";
-
-const { t } = useI18n();
-
-const props = defineProps<{ bookId: string; accounts: Account[]; currency: string; version: number }>();
-const emit = defineEmits<{ submitted: [] }>();
-
-const showAccountsModal = ref(false);
-
-interface OpeningRow {
-  debit: number | null;
-  credit: number | null;
-}
-
-const asOfDate = ref(localDateString());
-const rows = ref<Record<string, OpeningRow>>({});
-const existing = ref<JournalEntry | null>(null);
-const submitting = ref(false);
-const error = ref<string | null>(null);
-const successMessage = ref<string | null>(null);
-const { begin: beginLoad, isCurrent: isCurrentLoad } = useLatestRequest();
-
-const bsAccounts = computed(() =>
-  props.accounts.filter((account) => (account.type === "asset" || account.type === "liability" || account.type === "equity") && account.active !== false),
-);
-
-function ensureRows(): void {
-  for (const account of bsAccounts.value) {
-    if (!rows.value[account.code]) rows.value[account.code] = { debit: null, credit: null };
-  }
-}
-
-function onDebitInput(code: string): void {
-  const row = rows.value[code];
-  if (row.debit !== null && row.debit !== 0) row.credit = null;
-}
-function onCreditInput(code: string): void {
-  const row = rows.value[code];
-  if (row.credit !== null && row.credit !== 0) row.debit = null;
-}
-
-const imbalance = computed<number>(() => {
-  // Iterate the live bsAccounts (already active-filtered) rather
-  // than rows.value keys so a row for a now-inactive account
-  // doesn't tilt `balanced` against what `toApiLines` will
-  // actually post.
-  let sum = 0;
-  for (const account of bsAccounts.value) {
-    const row = rows.value[account.code];
-    if (!row) continue;
-    if (typeof row.debit === "number") sum += row.debit;
-    if (typeof row.credit === "number") sum -= row.credit;
-  }
-  return sum;
-});
-// An all-empty form is valid: it submits as a zero-line opening
-// marker so the user can unlock the rest of the UI without
-// committing to specific balances on day one.
-const balanced = computed(() => Math.abs(imbalance.value) <= 0.005);
-const imbalanceText = computed(() => formatAmount(imbalance.value, props.currency));
-const step = computed(() => inputStepFor(props.currency));
-
-function isPositiveAmount(value: unknown): value is number {
-  // Robust against the empty string `v-model.number` produces when
-  // the user clears a previously-typed field — without this, the
-  // skip condition `value === 0` was false for `""` and the form
-  // emitted ghost lines like `{accountCode: "3000"}` with no
-  // amount on either side.
-  return typeof value === "number" && Number.isFinite(value) && value > 0;
-}
-
-function toApiLines(): JournalLine[] {
-  const out: JournalLine[] = [];
-  // Iterate the visible bsAccounts list (which already filters
-  // out inactive accounts) rather than `rows.value` keys. A row
-  // for an account that was active when the user typed amounts
-  // and then got deactivated mid-edit would otherwise still post —
-  // the row stays in the map even after the v-for stops rendering
-  // it, so iterating keys would silently land entries on a
-  // soft-deleted account.
-  for (const account of bsAccounts.value) {
-    const row = rows.value[account.code];
-    if (!row) continue;
-    const debitOk = isPositiveAmount(row.debit);
-    const creditOk = isPositiveAmount(row.credit);
-    if (!debitOk && !creditOk) continue;
-    const line: JournalLine = { accountCode: account.code };
-    if (debitOk) line.debit = row.debit as number;
-    if (creditOk) line.credit = row.credit as number;
-    out.push(line);
-  }
-  return out;
-}
-
-function freshRows(): Record<string, OpeningRow> {
-  const out: Record<string, OpeningRow> = {};
-  for (const account of bsAccounts.value) out[account.code] = { debit: null, credit: null };
-  return out;
-}
-
-async function loadExisting(): Promise<void> {
-  // Always start from a fresh row map so a book without an
-  // opening doesn't inherit the previous book's draft values.
-  const token = beginLoad();
-  const next = freshRows();
-  const result = await getOpeningBalances(props.bookId);
-  // Drop the result if the user has switched books since this
-  // call started — otherwise stale rows would land on the new
-  // book's form.
-  if (!isCurrentLoad(token)) return;
-  if (!result.ok) {
-    existing.value = null;
-    rows.value = next;
-    return;
-  }
-  existing.value = result.data.opening;
-  if (result.data.opening) {
-    asOfDate.value = result.data.opening.date;
-    for (const line of result.data.opening.lines) {
-      next[line.accountCode] = { debit: line.debit ?? null, credit: line.credit ?? null };
-    }
-  } else {
-    asOfDate.value = localDateString();
-  }
-  rows.value = next;
-}
-
-async function onSubmit(): Promise<void> {
-  if (submitting.value || !balanced.value) return;
-  submitting.value = true;
-  error.value = null;
-  successMessage.value = null;
-  try {
-    const result = await setOpeningBalances({ bookId: props.bookId, asOfDate: asOfDate.value, lines: toApiLines() });
-    if (!result.ok) {
-      error.value = result.error;
-      return;
-    }
-    successMessage.value = t("pluginAccounting.openingForm.success");
-    emit("submitted");
-  } catch (err) {
-    error.value = errorMessage(err);
-  } finally {
-    submitting.value = false;
-  }
-}
-
-watch(
-  () => [props.bookId, props.version, props.accounts.length],
-  () => {
-    ensureRows();
-    void loadExisting();
-  },
-  { immediate: true },
-);
-</script>
-
-<style scoped>
-/* Hide the WebKit / Firefox spin buttons on amount inputs. The
-   step attribute still controls validation; this is purely UI.
-   Accounting amount fields don't benefit from a spinner — users
-   type the number and the up/down arrows just clutter the row. */
-input[type="number"]::-webkit-outer-spin-button,
-input[type="number"]::-webkit-inner-spin-button {
-  -webkit-appearance: none;
-  margin: 0;
-}
-input[type="number"] {
-  -moz-appearance: textfield;
-  appearance: textfield;
-}
-</style>

package/src/plugins/accounting/components/ProfitLoss.vue

@@ -1,160 +0,0 @@
-<template>
-  <div class="flex flex-col gap-3" data-testid="accounting-profit-loss">
-    <div class="flex flex-wrap items-end gap-3">
-      <DateRangePicker v-model="range" :fiscal-year-end="resolvedFiscalYearEnd" :opening-date="openingDate" />
-      <button class="h-8 px-2.5 rounded border border-gray-300 text-sm text-gray-600 hover:bg-gray-50" @click="refresh">
-        <span class="material-icons text-base align-middle">refresh</span>
-      </button>
-    </div>
-    <p v-if="loading" class="text-xs text-gray-400">{{ t("pluginAccounting.common.loading") }}</p>
-    <p v-else-if="error" class="text-xs text-red-500">{{ t("pluginAccounting.common.error", { error }) }}</p>
-    <template v-else-if="profitLoss">
-      <section class="border border-gray-200 rounded p-3">
-        <h4 class="text-sm font-semibold mb-2">{{ t("pluginAccounting.profitLoss.income") }}</h4>
-        <table class="w-full text-sm">
-          <tbody>
-            <tr
-              v-for="row in profitLoss.income.rows"
-              :key="row.accountCode"
-              class="border-b border-gray-100 hover:bg-blue-50 cursor-pointer focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-400"
-              tabindex="0"
-              role="button"
-              :aria-label="t('pluginAccounting.accounts.openLedgerAria', { code: row.accountCode, name: row.accountName })"
-              :data-testid="`accounting-pl-row-${row.accountCode}`"
-              @click="onRowClick(row.accountCode)"
-              @keydown.enter.prevent.self="onKeyActivate($event, row.accountCode)"
-              @keydown.space.prevent.self="onKeyActivate($event, row.accountCode)"
-            >
-              <td class="py-1 px-1">
-                <span class="font-mono text-[10px] text-gray-400 mr-2">{{ row.accountCode }}</span
-                >{{ row.accountName }}
-              </td>
-              <td class="py-1 px-1 text-right font-mono">{{ formatAmount(row.amount) }}</td>
-            </tr>
-          </tbody>
-          <tfoot>
-            <tr class="font-semibold border-t border-gray-300">
-              <td class="py-1 px-1">{{ t("pluginAccounting.balanceSheet.total") }}</td>
-              <td class="py-1 px-1 text-right">{{ formatAmount(profitLoss.income.total) }}</td>
-            </tr>
-          </tfoot>
-        </table>
-      </section>
-      <section class="border border-gray-200 rounded p-3">
-        <h4 class="text-sm font-semibold mb-2">{{ t("pluginAccounting.profitLoss.expense") }}</h4>
-        <table class="w-full text-sm">
-          <tbody>
-            <tr
-              v-for="row in profitLoss.expense.rows"
-              :key="row.accountCode"
-              class="border-b border-gray-100 hover:bg-blue-50 cursor-pointer focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-blue-400"
-              tabindex="0"
-              role="button"
-              :aria-label="t('pluginAccounting.accounts.openLedgerAria', { code: row.accountCode, name: row.accountName })"
-              :data-testid="`accounting-pl-row-${row.accountCode}`"
-              @click="onRowClick(row.accountCode)"
-              @keydown.enter.prevent.self="onKeyActivate($event, row.accountCode)"
-              @keydown.space.prevent.self="onKeyActivate($event, row.accountCode)"
-            >
-              <td class="py-1 px-1">
-                <span class="font-mono text-[10px] text-gray-400 mr-2">{{ row.accountCode }}</span
-                >{{ row.accountName }}
-              </td>
-              <td class="py-1 px-1 text-right font-mono">{{ formatAmount(row.amount) }}</td>
-            </tr>
-          </tbody>
-          <tfoot>
-            <tr class="font-semibold border-t border-gray-300">
-              <td class="py-1 px-1">{{ t("pluginAccounting.balanceSheet.total") }}</td>
-              <td class="py-1 px-1 text-right">{{ formatAmount(profitLoss.expense.total) }}</td>
-            </tr>
-          </tfoot>
-        </table>
-      </section>
-      <div class="flex justify-end items-center gap-2 text-sm font-semibold" data-testid="accounting-pl-net">
-        <span>{{ t("pluginAccounting.profitLoss.netIncome") }}</span>
-        <span :class="profitLoss.netIncome >= 0 ? 'text-green-600' : 'text-red-500'">{{ formatAmount(profitLoss.netIncome) }}</span>
-      </div>
-    </template>
-  </div>
-</template>
-
-<script setup lang="ts">
-import { computed, ref, watch } from "vue";
-import { useI18n } from "vue-i18n";
-import { getProfitLoss, type ProfitLoss } from "../api";
-import { formatAmount as formatAmountWithCurrency } from "../currencies";
-import { currentFiscalYearRange, resolveFiscalYearEnd, type DateRange, type FiscalYearEnd } from "../fiscalYear";
-import { useLatestRequest } from "./useLatestRequest";
-import DateRangePicker from "./DateRangePicker.vue";
-
-const { t } = useI18n();
-
-const props = defineProps<{
-  bookId: string;
-  currency: string;
-  version: number;
-  fiscalYearEnd?: FiscalYearEnd;
-  /** Opening-balance date for the active book — drives the "Lifetime"
-   *  shortcut in the date picker (from = openingDate, to = today).
-   *  When absent, the picker hides Lifetime; "All" still works. */
-  openingDate?: string;
-}>();
-
-const emit = defineEmits<{ selectAccount: [code: string] }>();
-
-const resolvedFiscalYearEnd = computed<FiscalYearEnd>(() => resolveFiscalYearEnd(props.fiscalYearEnd));
-
-function onRowClick(code: string): void {
-  emit("selectAccount", code);
-}
-
-function onKeyActivate(event: KeyboardEvent, code: string): void {
-  if (event.repeat) return;
-  emit("selectAccount", code);
-}
-
-// Default = current fiscal year. Reset by the bookId/fiscalYearEnd
-// watcher below so switching books or changing the FY-end in
-// settings drops a stale custom range from the prior book.
-const range = ref<DateRange>(currentFiscalYearRange(resolvedFiscalYearEnd.value));
-const profitLoss = ref<ProfitLoss | null>(null);
-const loading = ref(false);
-const error = ref<string | null>(null);
-const { begin: beginRequest, isCurrent } = useLatestRequest();
-
-function formatAmount(value: number): string {
-  return formatAmountWithCurrency(value, props.currency);
-}
-
-async function refresh(): Promise<void> {
-  const token = beginRequest();
-  loading.value = true;
-  error.value = null;
-  try {
-    // P&L always sends a range. Empty-side gets a sentinel so "All"
-    // (both empty) means "every entry" rather than an empty window.
-    const fromBound = range.value.from || "0000-01-01";
-    const toBound = range.value.to || "9999-12-31";
-    const result = await getProfitLoss({ kind: "range", from: fromBound, to: toBound }, props.bookId);
-    if (!isCurrent(token)) return;
-    if (!result.ok) {
-      error.value = result.error;
-      profitLoss.value = null;
-      return;
-    }
-    profitLoss.value = result.data.profitLoss;
-  } finally {
-    if (isCurrent(token)) loading.value = false;
-  }
-}
-
-watch(
-  () => [props.bookId, resolvedFiscalYearEnd.value],
-  () => {
-    range.value = currentFiscalYearRange(resolvedFiscalYearEnd.value);
-  },
-);
-
-watch(() => [props.bookId, props.version, range.value.from, range.value.to], refresh, { immediate: true });
-</script>

package/src/plugins/accounting/components/accountDraft.ts

@@ -1,13 +0,0 @@
-// Shared draft shape for the AccountsModal editor row. Lives in
-// its own module so AccountsModal.vue and AccountEditor.vue can
-// both type the prop / emit without one importing the other —
-// they form a parent / child pair, not a re-export chain.
-
-import type { AccountType } from "../api";
-
-export interface AccountDraft {
-  code: string;
-  name: string;
-  type: AccountType;
-  note: string;
-}

package/src/plugins/accounting/components/accountNumbering.ts

@@ -1,103 +0,0 @@
-// Account-code numbering convention. The chart of accounts uses
-// 4-digit codes whose leading digit identifies the type:
-//
-//   1xxx → asset
-//   2xxx → liability
-//   3xxx → equity
-//   4xxx → income
-//   5xxx → expense
-//
-// Within those bands, the second digit `4` is reserved for tax-
-// related accounts on both sides of the balance sheet:
-//
-//   14xx → tax-related current assets
-//          (1400 Input Tax Receivable / 仮払消費税, plus future
-//           withholding-tax-receivable / etc. siblings)
-//   24xx → tax-related current liabilities
-//          (2400 Sales Tax Payable / 仮受消費税, plus future
-//           withholding-tax-payable / etc. siblings)
-//
-// Special-case UI (Ledger T-number column, JournalEntryForm
-// per-line tax-registration ID input) is **input-tax-only** — it
-// keys off `isTaxAccountCode`, which matches 14xx (purchase side)
-// only. Output-tax / sales-side lines (24xx) intentionally don't
-// surface a counterparty registration field: the seller's
-// obligation is to put their *own* registration number on the
-// invoice they issue, not to capture the customer's. So a custom
-// suspense account added in the 14xx band participates without
-// any opt-in step; 24xx accounts book the liability without the
-// extra column.
-//
-// Lives in its own module so AccountsModal, AccountEditor, and the
-// validation helper can share the same constants without circular
-// imports between Vue components.
-
-import type { Account, AccountType } from "../api";
-
-export const ACCOUNT_TYPE_PREFIX: Record<AccountType, number> = {
-  asset: 1,
-  liability: 2,
-  equity: 3,
-  income: 4,
-  expense: 5,
-};
-
-const TAX_ACCOUNT_PREFIXES: readonly string[] = ["14"];
-
-/** Returns `true` for codes whose first two digits identify a
- *  tax-related current asset (`14xx`) — i.e. the input-tax /
- *  purchase side of consumption / sales / VAT bookkeeping. Drives
- *  Ledger column visibility and the JournalEntryForm per-line
- *  tax-registration ID input. Output-tax (24xx) is intentionally
- *  excluded: the counterparty's registration ID is only
- *  load-bearing for input-tax-credit eligibility on purchases. */
-export function isTaxAccountCode(code: string): boolean {
-  return TAX_ACCOUNT_PREFIXES.some((prefix) => code.startsWith(prefix));
-}
-
-const ACCOUNT_CODE_RE = /^\d{4}$/;
-const SUGGESTED_GAP = 10;
-
-export function isValidAccountCode(code: string): boolean {
-  return ACCOUNT_CODE_RE.test(code);
-}
-
-export function typeForCode(code: string): AccountType | null {
-  if (!isValidAccountCode(code)) return null;
-  const leading = Number.parseInt(code[0], 10);
-  for (const [type, prefix] of Object.entries(ACCOUNT_TYPE_PREFIX) as [AccountType, number][]) {
-    if (prefix === leading) return type;
-  }
-  return null;
-}
-
-export function codeMatchesType(code: string, type: AccountType): boolean {
-  return typeForCode(code) === type;
-}
-
-/** Suggest the next free 4-digit code for `type`. Picks max-in-range
- *  + SUGGESTED_GAP so users keep room to insert sibling accounts
- *  later (the standard accounting convention). Falls back to the
- *  prefix base when the range is empty, and to max+1 when +gap would
- *  spill out of the 4-digit prefix window. */
-export function suggestNextCode(type: AccountType, accounts: readonly Account[]): string {
-  const prefix = ACCOUNT_TYPE_PREFIX[type];
-  const inRange: number[] = [];
-  for (const account of accounts) {
-    if (!isValidAccountCode(account.code)) continue;
-    const value = Number.parseInt(account.code, 10);
-    if (Math.floor(value / 1000) !== prefix) continue;
-    inRange.push(value);
-  }
-  if (inRange.length === 0) return `${prefix}000`;
-  const max = Math.max(...inRange);
-  const candidate = max + SUGGESTED_GAP;
-  if (Math.floor(candidate / 1000) === prefix && candidate <= 9999) return String(candidate);
-  // Range is dense at the top — fall back to a unit step. If even
-  // that overflows the prefix window the chart is essentially full
-  // for that type; surface the overflow rather than silently
-  // suggesting a code in the next type's range.
-  const fallback = max + 1;
-  if (Math.floor(fallback / 1000) === prefix && fallback <= 9999) return String(fallback);
-  return `${prefix}999`;
-}

package/src/plugins/accounting/components/accountValidation.ts

@@ -1,75 +0,0 @@
-// Pure validation for the AccountsModal editor draft. Lives in its
-// own module so unit tests can exercise the boundary cases (reserved
-// `_` prefix, duplicate code, empty fields) without spinning up Vue
-// or i18n. The component maps the returned error code to a
-// localized message.
-//
-// The `_`-prefix rule mirrors the server's check in
-// server/accounting/service.ts:upsertAccount — codes starting with
-// `_` are reserved for synthetic report rows. Catching it client-
-// side avoids a round-trip and surfaces the localized message
-// instead of the raw server error.
-
-import type { Account } from "../api";
-import type { AccountDraft } from "./accountDraft";
-import { codeMatchesType, isValidAccountCode } from "./accountNumbering";
-
-export const RESERVED_PREFIX = "_";
-
-export type CodeValidationError = "emptyCode" | "reservedCode" | "invalidCodeFormat" | "codeTypeMismatch" | "duplicateCode";
-export type NameValidationError = "emptyName" | "duplicateName";
-export type AccountValidationError = CodeValidationError | NameValidationError;
-
-/**
- * Validate just the code field. Split out from the full draft
- * validator so AccountEditor can paint a per-field red border in
- * realtime without re-running the name check on every keystroke.
- */
-export function validateCodeField(draft: AccountDraft, existing: readonly Account[], isNew: boolean): CodeValidationError | null {
-  const trimmedCode = draft.code.trim();
-  if (trimmedCode.length === 0) return "emptyCode";
-  if (trimmedCode.startsWith(RESERVED_PREFIX)) return "reservedCode";
-  // 4-digit numbering is enforced for new accounts only: pre-existing
-  // books may already hold legacy codes the user added before the
-  // rule landed, and changing the code would orphan their journal
-  // lines (codes are immutable once created — see codeReadOnlyHint).
-  if (isNew && !isValidAccountCode(trimmedCode)) return "invalidCodeFormat";
-  if (isNew && !codeMatchesType(trimmedCode, draft.type)) return "codeTypeMismatch";
-  if (isNew && existing.some((account) => account.code === trimmedCode)) return "duplicateCode";
-  return null;
-}
-
-/**
- * Validate just the name field. Empty + duplicate (case-insensitive,
- * trimmed) against other accounts. On edit, the account being edited
- * is excluded from the duplicate check via `draft.code` — otherwise
- * every save would flag the user's own row as a collision.
- */
-export function validateNameField(draft: AccountDraft, existing: readonly Account[], isNew: boolean): NameValidationError | null {
-  const trimmedName = draft.name.trim();
-  if (trimmedName.length === 0) return "emptyName";
-  const folded = trimmedName.toLowerCase();
-  const collides = existing.some((account) => {
-    if (!isNew && account.code === draft.code.trim()) return false;
-    return account.name.trim().toLowerCase() === folded;
-  });
-  if (collides) return "duplicateName";
-  return null;
-}
-
-/**
- * Validate a draft about to be sent to `upsertAccount`. Returns
- * `null` on success or an error code on failure. Caller maps the
- * code to a localized message.
- *
- * `existing` is the current chart of accounts — used to detect a
- * duplicate code on a brand-new entry (otherwise the server would
- * silently overwrite the existing account, which is rarely what
- * the user typing into the "Add account" form intended).
- *
- * Code errors take precedence over name errors so the user fixes
- * one stable issue at a time as they type.
- */
-export function validateAccountDraft(draft: AccountDraft, existing: readonly Account[], isNew: boolean): AccountValidationError | null {
-  return validateCodeField(draft, existing, isNew) ?? validateNameField(draft, existing, isNew);
-}

package/src/plugins/accounting/components/useLatestRequest.ts

@@ -1,44 +0,0 @@
-// Stale-response guard for watcher-driven async fetches.
-//
-// Pattern: a watcher fires on bookId / filter / version changes
-// and kicks off `apiPost(...)`. Without coordination, a slower
-// earlier request can resolve after a newer one and overwrite the
-// fresh state with stale data. This composable hands out a
-// monotonic token before each await; the caller checks that the
-// token is still current after the await before mutating state.
-//
-// Usage:
-//
-//   const { begin, isCurrent } = useLatestRequest();
-//   async function refresh() {
-//     const token = begin();
-//     const result = await api.fetch(...);
-//     if (!isCurrent(token)) return;          // a newer refresh started
-//     applyState(result);
-//   }
-//
-// Cheap and dependency-free. Each component holds its own
-// `useLatestRequest()` instance — there's no shared state across
-// components.
-
-export interface LatestRequestApi {
-  /** Returns the token of the new request. Increments the
-   *  internal counter; older outstanding requests will fail
-   *  `isCurrent`. */
-  begin: () => number;
-  /** True if `token` is still the most recently issued one. */
-  isCurrent: (token: number) => boolean;
-}
-
-export function useLatestRequest(): LatestRequestApi {
-  let counter = 0;
-  return {
-    begin(): number {
-      counter += 1;
-      return counter;
-    },
-    isCurrent(token: number): boolean {
-      return token === counter;
-    },
-  };
-}