@jjlmoya/utils-civic 1.1.0

package/src/tool/election-seat-apportionment-calculator/logic.ts

@@ -0,0 +1,268 @@
+export type AllocationMethod = 'dhondt' | 'sainte-lague' | 'hare';
+
+export interface PartyInput {
+  name: string;
+  votes: number;
+}
+
+export interface ElectionInput {
+  parties: PartyInput[];
+  totalSeats: number;
+  thresholdPercent: number;
+  method: AllocationMethod;
+  districtSeats?: number[];
+}
+
+export interface PartyAllocation {
+  name: string;
+  votes: number;
+  sharePercent: number;
+  seats: number;
+  seatSharePercent: number;
+  excluded: boolean;
+}
+
+export interface SeatEvent {
+  partyName: string;
+  seatNumber: number;
+  quotient: number;
+  remainder?: number;
+}
+
+export interface DistrictAllocation {
+  label: string;
+  seats: number;
+  quota: number;
+  parties: PartyAllocation[];
+  events: SeatEvent[];
+}
+
+export interface SensitivityChange {
+  thresholdPercent: number;
+  seatsByParty: Record<string, number>;
+  changedParties: string[];
+}
+
+export interface ApportionmentResult {
+  method: AllocationMethod;
+  totalSeats: number;
+  validVotes: number;
+  eligibleVotes: number;
+  excludedVotes: number;
+  thresholdPercent: number;
+  effectiveThresholdPercent: number;
+  partyAllocations: PartyAllocation[];
+  events: SeatEvent[];
+  districts: DistrictAllocation[];
+  sensitivity: {
+    lower: SensitivityChange;
+    higher: SensitivityChange;
+  };
+}
+
+interface EligibleParty extends PartyInput {
+  index: number;
+  sharePercent: number;
+}
+
+interface BaseAllocation {
+  partyAllocations: PartyAllocation[];
+  events: SeatEvent[];
+  districts: DistrictAllocation[];
+  eligibleVotes: number;
+}
+
+const roundValue = (value: number, digits = 6): number => {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+};
+
+const assertSeats = (totalSeats: number): void => {
+  if (!Number.isInteger(totalSeats) || totalSeats < 1 || totalSeats > 500) {
+    throw new RangeError('Total seats must be an integer from 1 to 500.');
+  }
+};
+
+const assertThreshold = (thresholdPercent: number): void => {
+  if (!Number.isFinite(thresholdPercent) || thresholdPercent < 0 || thresholdPercent > 100) {
+    throw new RangeError('Threshold must be between 0 and 100 percent.');
+  }
+};
+
+const assertMethod = (method: AllocationMethod): void => {
+  if (!['dhondt', 'sainte-lague', 'hare'].includes(method)) {
+    throw new RangeError('Choose a supported allocation method.');
+  }
+};
+
+const assertParties = (parties: PartyInput[]): void => {
+  if (parties.length < 2) throw new RangeError('Add at least two parties.');
+  const names = new Set<string>();
+  for (const party of parties) {
+    const name = party.name.trim();
+    if (!name || names.has(name.toLowerCase())) throw new RangeError('Each party needs a unique name.');
+    if (!Number.isFinite(party.votes) || party.votes < 0) throw new RangeError('Votes must be zero or a positive number.');
+    names.add(name.toLowerCase());
+  }
+  if (parties.every((party) => party.votes === 0)) throw new RangeError('Enter at least one vote before calculating.');
+};
+
+const assertDistricts = (districtSeats: number[] | undefined, totalSeats: number): void => {
+  if (!districtSeats) return;
+  if (districtSeats.length < 2 || districtSeats.some((seats) => !Number.isInteger(seats) || seats < 1)) {
+    throw new RangeError('District seats must contain at least two positive integers.');
+  }
+  const districtTotal = districtSeats.reduce((sum, seats) => sum + seats, 0);
+  if (districtTotal !== totalSeats) throw new RangeError('District seats must add up to the total seats.');
+};
+
+const assertValidInput = (input: ElectionInput): void => {
+  assertSeats(input.totalSeats);
+  assertThreshold(input.thresholdPercent);
+  assertMethod(input.method);
+  assertParties(input.parties);
+  assertDistricts(input.districtSeats, input.totalSeats);
+};
+
+const getEligibleParties = (input: ElectionInput, validVotes: number): EligibleParty[] => input.parties
+  .map((party, index) => ({
+    ...party,
+    index,
+    sharePercent: (party.votes / validVotes) * 100,
+  }))
+  .filter((party) => party.sharePercent >= input.thresholdPercent);
+
+const compareNumbers = (left: number, right: number): number => {
+  if (Math.abs(left - right) < 1e-10) return 0;
+  return left > right ? -1 : 1;
+};
+
+const compareEvents = (left: SeatEvent & { index: number; votes: number }, right: SeatEvent & { index: number; votes: number }): number => (
+  compareNumbers(left.quotient, right.quotient)
+  || compareNumbers(left.votes, right.votes)
+  || left.index - right.index
+);
+
+const allocateHighestAverage = (parties: EligibleParty[], seats: number, method: AllocationMethod): { events: SeatEvent[]; quota: number } => {
+  const divisors = method === 'dhondt' ? (seat: number) => seat : (seat: number) => (seat * 2) - 1;
+  const events = parties.flatMap((party) => Array.from({ length: seats }, (_, index) => ({
+    partyName: party.name,
+    seatNumber: index + 1,
+    quotient: party.votes / divisors(index + 1),
+    index: party.index,
+    votes: party.votes,
+  })));
+  return { events: events.sort(compareEvents).slice(0, seats).map(({ partyName, seatNumber, quotient }) => ({ partyName, seatNumber, quotient })), quota: 0 };
+};
+
+const allocateLargestRemainder = (parties: EligibleParty[], seats: number): { events: SeatEvent[]; quota: number } => {
+  const totalVotes = parties.reduce((sum, party) => sum + party.votes, 0);
+  const quota = totalVotes / seats;
+  const initial = parties.map((party) => ({
+    party,
+    fullSeats: quota > 0 ? Math.floor(party.votes / quota) : 0,
+    remainder: quota > 0 ? party.votes % quota : 0,
+  }));
+  const remainingSeats = seats - initial.reduce((sum, item) => sum + item.fullSeats, 0);
+  const ranked = [...initial].sort((left, right) => (
+    compareNumbers(left.remainder, right.remainder)
+    || compareNumbers(left.party.votes, right.party.votes)
+    || left.party.index - right.party.index
+  ));
+  const events: SeatEvent[] = [];
+  for (const item of initial) {
+    for (let seat = 1; seat <= item.fullSeats; seat += 1) {
+      events.push({ partyName: item.party.name, seatNumber: seat, quotient: quota, remainder: item.remainder });
+    }
+  }
+  ranked.slice(0, remainingSeats).forEach((item) => {
+    const currentSeats = initial.find((candidate) => candidate.party.index === item.party.index)?.fullSeats ?? 0;
+    events.push({ partyName: item.party.name, seatNumber: currentSeats + 1, quotient: quota, remainder: item.remainder });
+  });
+  return { events, quota };
+};
+
+const allocateDistrict = (parties: EligibleParty[], seats: number, label: string, method: AllocationMethod): DistrictAllocation => {
+  const allocation = method === 'hare'
+    ? allocateLargestRemainder(parties, seats)
+    : allocateHighestAverage(parties, seats, method);
+  const seatsByParty = new Map<string, number>();
+  allocation.events.forEach((event) => seatsByParty.set(event.partyName, (seatsByParty.get(event.partyName) ?? 0) + 1));
+  return {
+    label,
+    seats,
+    quota: allocation.quota,
+    events: allocation.events,
+    parties: parties.map((party) => ({
+      name: party.name,
+      votes: party.votes,
+      sharePercent: roundValue(party.sharePercent, 2),
+      seats: seatsByParty.get(party.name) ?? 0,
+      seatSharePercent: roundValue(((seatsByParty.get(party.name) ?? 0) / seats) * 100, 2),
+      excluded: false,
+    })),
+  };
+};
+
+const calculateBase = (input: ElectionInput): BaseAllocation => {
+  const validVotes = input.parties.reduce((sum, party) => sum + party.votes, 0);
+  const eligibleParties = getEligibleParties(input, validVotes);
+  const eligibleVotes = eligibleParties.reduce((sum, party) => sum + party.votes, 0);
+  const districtSeats = input.districtSeats ?? [input.totalSeats];
+  const districts = districtSeats.map((seats, index) => allocateDistrict(eligibleParties, seats, `District ${index + 1}`, input.method));
+  const seatsByParty = new Map<string, number>();
+  const events = districts.flatMap((district) => district.events);
+  events.forEach((event) => seatsByParty.set(event.partyName, (seatsByParty.get(event.partyName) ?? 0) + 1));
+  const partyAllocations = input.parties.map((party) => {
+    const eligible = eligibleParties.some((candidate) => candidate.name === party.name);
+    const seats = seatsByParty.get(party.name) ?? 0;
+    return {
+      name: party.name,
+      votes: party.votes,
+      sharePercent: roundValue((party.votes / validVotes) * 100, 2),
+      seats,
+      seatSharePercent: roundValue((seats / input.totalSeats) * 100, 2),
+      excluded: !eligible,
+    };
+  });
+  return { partyAllocations, events, districts: input.districtSeats ? districts : [], eligibleVotes };
+};
+
+const getSeatMap = (allocations: PartyAllocation[]): Record<string, number> => Object.fromEntries(allocations.map((party) => [party.name, party.seats]));
+
+const getChangedParties = (base: Record<string, number>, comparison: Record<string, number>): string[] => Object.keys(base)
+  .filter((name) => base[name] !== comparison[name]);
+
+const buildSensitivity = (input: ElectionInput, base: BaseAllocation, thresholdPercent: number): SensitivityChange => {
+  const comparison = calculateBase({ ...input, thresholdPercent });
+  const seatsByParty = getSeatMap(comparison.partyAllocations);
+  return {
+    thresholdPercent,
+    seatsByParty,
+    changedParties: getChangedParties(getSeatMap(base.partyAllocations), seatsByParty),
+  };
+};
+
+export const calculateApportionment = (input: ElectionInput): ApportionmentResult => {
+  assertValidInput(input);
+  const validVotes = input.parties.reduce((sum, party) => sum + party.votes, 0);
+  const base = calculateBase(input);
+  const winners = base.partyAllocations.filter((party) => party.seats > 0);
+  const effectiveThresholdPercent = winners.length > 0 ? Math.min(...winners.map((party) => party.sharePercent)) : 0;
+  return {
+    method: input.method,
+    totalSeats: input.totalSeats,
+    validVotes,
+    eligibleVotes: base.eligibleVotes,
+    excludedVotes: validVotes - base.eligibleVotes,
+    thresholdPercent: roundValue(input.thresholdPercent, 2),
+    effectiveThresholdPercent: roundValue(effectiveThresholdPercent, 2),
+    partyAllocations: base.partyAllocations,
+    events: base.events,
+    districts: base.districts,
+    sensitivity: {
+      lower: buildSensitivity(input, base, Math.max(0, roundValue(input.thresholdPercent - 1, 2))),
+      higher: buildSensitivity(input, base, Math.min(100, roundValue(input.thresholdPercent + 1, 2))),
+    },
+  };
+};

package/src/tool/election-seat-apportionment-calculator/seo.astro

@@ -0,0 +1,14 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { electionSeatApportionmentCalculator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props as Props;
+const content = await electionSeatApportionmentCalculator.i18n[locale]?.();
+---
+
+{content && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/election-seat-apportionment-calculator/sharing.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest';
+import { buildShareUrl, decodeSharePayload, encodeSharePayload, hasSharePayload, readSharePayload } from './sharing';
+import type { ElectionInput } from './logic';
+
+const input: ElectionInput = {
+  parties: [
+    { name: 'Árbol', votes: 42000 },
+    { name: 'Río', votes: 31000 },
+  ],
+  totalSeats: 12,
+  thresholdPercent: 5,
+  method: 'hare',
+  districtSeats: [5, 7],
+};
+
+describe('shareable election scenarios', () => {
+  it('round-trips the complete election input, including Unicode names and districts', () => {
+    expect(decodeSharePayload(encodeSharePayload(input))).toEqual(input);
+  });
+
+  it('builds a stable result query parameter without dropping the page route', () => {
+    const url = buildShareUrl('https://example.test/en/election-seat-apportionment-calculator?theme=dark', input);
+    expect(url).toContain('/en/election-seat-apportionment-calculator?theme=dark&result=');
+    expect(readSharePayload(new URL(url).search)).toEqual(input);
+    expect(hasSharePayload(new URL(url).search)).toBe(true);
+  });
+
+  it('rejects malformed or unsupported shared results', () => {
+    expect(decodeSharePayload('{"v":1,"method":"unknown"}')).toBeNull();
+    expect(decodeSharePayload('{"v":2}')).toBeNull();
+    expect(readSharePayload('?result=not-json')).toBeNull();
+    expect(hasSharePayload('')).toBe(false);
+  });
+});

package/src/tool/election-seat-apportionment-calculator/sharing.ts

@@ -0,0 +1,88 @@
+import type { ElectionInput, AllocationMethod, PartyInput } from './logic';
+
+export const SHARED_RESULT_PARAM = 'result';
+
+interface SharePayload {
+  v: 1;
+  parties: PartyInput[];
+  totalSeats: number;
+  thresholdPercent: number;
+  method: AllocationMethod;
+  districtSeats?: number[];
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && value !== null;
+
+const isMethod = (value: unknown): value is AllocationMethod => value === 'dhondt' || value === 'sainte-lague' || value === 'hare';
+
+const isFiniteNumber = (value: unknown): value is number => typeof value === 'number' && Number.isFinite(value);
+
+const readParty = (value: unknown): PartyInput | null => {
+  if (!isRecord(value)) return null;
+  if (typeof value.name !== 'string') return null;
+  if (!isFiniteNumber(value.votes)) return null;
+  return { name: value.name, votes: value.votes };
+};
+
+const readParties = (value: unknown): PartyInput[] | null => {
+  if (!Array.isArray(value)) return null;
+  const parties = value.map(readParty);
+  return parties.every((party): party is PartyInput => party !== null) ? parties : null;
+};
+
+const isValidMetadata = (value: unknown): value is SharePayload => {
+  if (!isRecord(value)) return false;
+  if (value.v !== 1) return false;
+  if (!isFiniteNumber(value.totalSeats)) return false;
+  if (!isFiniteNumber(value.thresholdPercent)) return false;
+  return isMethod(value.method);
+};
+
+const readDistrictSeats = (value: unknown): number[] | null | undefined => {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value)) return null;
+  if (value.some((seats) => !isFiniteNumber(seats))) return null;
+  return value;
+};
+
+export const encodeSharePayload = (input: ElectionInput): string => JSON.stringify({
+  v: 1,
+  parties: input.parties.map(({ name, votes }) => ({ name, votes })),
+  totalSeats: input.totalSeats,
+  thresholdPercent: input.thresholdPercent,
+  method: input.method,
+  ...(input.districtSeats ? { districtSeats: input.districtSeats } : {}),
+} satisfies SharePayload);
+
+export const decodeSharePayload = (raw: string | null): ElectionInput | null => {
+  if (!raw) return null;
+  try {
+    const payload = JSON.parse(raw) as unknown;
+    if (!isValidMetadata(payload)) return null;
+    const parties = readParties(payload.parties);
+    if (!parties) return null;
+    const districtSeats = readDistrictSeats(payload.districtSeats);
+    if (districtSeats === null) return null;
+    return {
+      parties,
+      totalSeats: payload.totalSeats,
+      thresholdPercent: payload.thresholdPercent,
+      method: payload.method,
+      ...(districtSeats ? { districtSeats } : {}),
+    };
+  } catch {
+    return null;
+  }
+};
+
+export const readSharePayload = (search: string): ElectionInput | null => (
+  decodeSharePayload(new URLSearchParams(search).get(SHARED_RESULT_PARAM))
+);
+
+export const hasSharePayload = (search: string): boolean => new URLSearchParams(search).has(SHARED_RESULT_PARAM);
+
+export const buildShareUrl = (currentUrl: string, input: ElectionInput): string => {
+  const url = new URL(currentUrl);
+  url.searchParams.set(SHARED_RESULT_PARAM, encodeSharePayload(input));
+  return url.toString();
+};

package/src/tool/election-seat-apportionment-calculator/storage.ts

@@ -0,0 +1,28 @@
+import type { ElectionInput } from './logic';
+
+const STORAGE_KEY = 'civic-election-seat-model';
+
+export const loadElectionInput = (): ElectionInput | null => {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    return raw ? JSON.parse(raw) as ElectionInput : null;
+  } catch {
+    return null;
+  }
+};
+
+export const saveElectionInput = (input: ElectionInput): void => {
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(input));
+  } catch {
+    return;
+  }
+};
+
+export const clearElectionInput = (): void => {
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch {
+    return;
+  }
+};

package/src/tool/election-seat-apportionment-calculator/ui.ts

@@ -0,0 +1,92 @@
+export interface ElectionSeatUI {
+  [key: string]: string;
+  methodLabel: string;
+  allocationTitle: string;
+  eventsTitle: string;
+  sensitivityTitle: string;
+  dhondtLabel: string;
+  sainteLagueLabel: string;
+  hareLabel: string;
+  partiesLabel: string;
+  partyNameLabel: string;
+  votesLabel: string;
+  addParty: string;
+  removeParty: string;
+  shareResult: string;
+  shareCopied: string;
+  shareCopyFallback: string;
+  invalidSharedResult: string;
+  totalSeatsLabel: string;
+  thresholdLabel: string;
+  districtsLabel: string;
+  districtsHelp: string;
+  districtsPlaceholder: string;
+  reset: string;
+  allocatedSeatsLabel: string;
+  voteShareLabel: string;
+  seatShareLabel: string;
+  excludedLabel: string;
+  chamberLabel: string;
+  quotientLabel: string;
+  remainderLabel: string;
+  eventLabel: string;
+  eligibleVotesLabel: string;
+  excludedVotesLabel: string;
+  effectiveThresholdLabel: string;
+  sensitivityLabel: string;
+  lowerThresholdLabel: string;
+  higherThresholdLabel: string;
+  changedLabel: string;
+  noChangesLabel: string;
+  districtAssumption: string;
+  modelNotice: string;
+  emptyState: string;
+  invalidNumber: string;
+  seatUnit: string;
+}
+
+export const ui: ElectionSeatUI = {
+  methodLabel: 'Allocation method',
+  allocationTitle: 'Seat allocation',
+  eventsTitle: 'The next seats are decided here',
+  sensitivityTitle: 'What changes around the threshold',
+  dhondtLabel: "D'Hondt highest averages",
+  sainteLagueLabel: 'Sainte-Lague highest averages',
+  hareLabel: 'Hare quota and largest remainder',
+  partiesLabel: 'Votes by party or list',
+  partyNameLabel: 'Party or list name',
+  votesLabel: 'Votes',
+  addParty: 'Add party',
+  removeParty: 'Remove party',
+  shareResult: 'Copy share link',
+  shareCopied: 'Share link copied.',
+  shareCopyFallback: 'Copy the share link from the dialog.',
+  invalidSharedResult: 'This shared result link is invalid. Showing the example instead.',
+  totalSeatsLabel: 'Seats to allocate',
+  thresholdLabel: 'Eligibility threshold',
+  districtsLabel: 'Optional district grouping',
+  districtsHelp: 'Enter seat counts separated by commas. The model applies the same vote profile in each district.',
+  districtsPlaceholder: 'Example: 10, 8, 7',
+  reset: 'Reset example',
+  allocatedSeatsLabel: 'Seats allocated',
+  voteShareLabel: 'Vote share',
+  seatShareLabel: 'Seat share',
+  excludedLabel: 'Excluded by threshold',
+  chamberLabel: 'Seat chamber',
+  quotientLabel: 'Quotient',
+  remainderLabel: 'Remainder',
+  eventLabel: 'Seat award order',
+  eligibleVotesLabel: 'Eligible votes',
+  excludedVotesLabel: 'Votes excluded',
+  effectiveThresholdLabel: 'Observed seat threshold',
+  sensitivityLabel: 'Threshold sensitivity',
+  lowerThresholdLabel: 'At threshold minus 1 point',
+  higherThresholdLabel: 'At threshold plus 1 point',
+  changedLabel: 'Changed seats',
+  noChangesLabel: 'No seat changes in this test',
+  districtAssumption: 'District mode is a scenario: it repeats the entered national vote profile in every district and does not replace official district results.',
+  modelNotice: 'Educational model only. This is not an official election result, legal advice, or a prediction.',
+  emptyState: 'Enter votes to reveal the seat chamber.',
+  invalidNumber: 'Use a valid non-negative number.',
+  seatUnit: 'seats',
+};

package/src/tools.ts

@@ -0,0 +1,7 @@
+export { ALL_ENTRIES } from './entries';
+import type { ToolDefinition } from './types';
+import { ELECTION_SEAT_APPORTIONMENT_CALCULATOR_TOOL } from './tool/election-seat-apportionment-calculator';
+
+export const ALL_TOOLS: ToolDefinition[] = [
+  ELECTION_SEAT_APPORTIONMENT_CALCULATOR_TOOL,
+];

package/src/types.ts

@@ -0,0 +1,69 @@
+import type { SEOSection } from '@jjlmoya/utils-shared';
+
+export type { SEOSection };
+
+export type KnownLocale =
+  | 'ar' | 'da' | 'de' | 'en' | 'es' | 'fi'
+  | 'fr' | 'id' | 'it' | 'ja' | 'ko' | 'nb' | 'nl'
+  | 'pl' | 'pt' | 'ru' | 'sv' | 'tr' | 'zh';
+
+export interface FAQItem {
+  question: string;
+  answer: string;
+}
+
+export interface BibliographyEntry {
+  name: string;
+  url: string;
+}
+
+export interface HowToStep {
+  name: string;
+  text: string;
+}
+
+export interface ToolLocaleContent<TUI extends Record<string, string> = Record<string, string>> {
+  slug: string;
+  title: string;
+  description: string;
+  ui: TUI;
+  seo: SEOSection[];
+  faq: FAQItem[];
+  bibliography: BibliographyEntry[];
+  howTo: HowToStep[];
+  schemas: Record<string, unknown>[];
+}
+
+export interface CategoryLocaleContent {
+  slug: string;
+  title: string;
+  description: string;
+  seo: SEOSection[];
+}
+
+export type LocaleLoader<T> = () => Promise<T>;
+
+export type LocaleMap<T> = Partial<Record<KnownLocale, LocaleLoader<T>>>;
+
+export interface CivicToolEntry<TUI extends Record<string, string> = Record<string, string>> {
+  id: string;
+  icons: {
+    bg: string;
+    fg: string;
+  };
+  i18n: LocaleMap<ToolLocaleContent<TUI>>;
+}
+
+export interface CivicCategoryEntry {
+  icon: string;
+  tools: CivicToolEntry[];
+  i18n: LocaleMap<CategoryLocaleContent>;
+}
+
+export interface ToolDefinition {
+  entry: CivicToolEntry;
+  Component: unknown;
+  SEOComponent: unknown;
+  BibliographyComponent: unknown;
+}
+

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "extends": "astro/tsconfigs/strictest",
+    "include": ["src/**/*", ".astro/types.d.ts"],
+    "compilerOptions": {
+        "baseUrl": ".",
+        "strictNullChecks": true,
+        "noImplicitAny": true,
+        "strict": true,
+        "types": ["astro/client", "astro/jsx-runtime"],
+        "jsx": "preserve",
+        "jsxImportSource": "astro"
+    },
+    "exclude": ["node_modules", "dist"]
+}
+

package/vitest.config.ts

@@ -0,0 +1,20 @@
+import { defineConfig } from 'vitest/config';
+import path from 'path';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+  },
+  resolve: {
+    alias: [
+      {
+        find: /^(.*)\.astro$/,
+        replacement: path.resolve(__dirname, './src/tests/mocks/astro_mock.js')
+      }
+    ]
+  },
+  ssr: {
+    external: ['astro']
+  }
+});
+