From e1786f73849dc05a2406b2740d3c97dba0054878 Mon Sep 17 00:00:00 2001 From: Jose Selesan Date: Fri, 29 May 2026 10:29:20 -0300 Subject: [PATCH] feat(expenses): implement responsive dialog for expense management and create expense provider - Added ResponsiveDialog component for handling responsive dialogs in the UI. - Created ExpensesProvider to manage state and API interactions for expenses. - Developed ExpensesTabContent to display expenses with filtering options and dialogs for new and pay expense actions. - Implemented ExpensesTable for rendering expense data in a tabular format with actions. - Added dialogs for creating new expenses and paying existing ones with form validation. - Introduced PeriodicExpenseForm for managing periodic expenses with month selection. - Created PeriodicExpensesTabContent to manage and display periodic expenses with create/edit functionality. - Added GenerateCurrentMonthDialog for confirming monthly expense generation. - Implemented PeriodicExpensesTable for displaying periodic expenses with edit and delete actions. --- apps/backend/package.json | 3 +- .../20260529122915_add_expenses/migration.sql | 34 + apps/backend/prisma/schema.prisma | 37 + apps/backend/src/index.ts | 4 + .../src/modules/expenses/expense.job.ts | 16 + .../src/modules/expenses/expenses.routes.ts | 23 + .../src/modules/expenses/expenses.service.ts | 160 + .../handlers/createNonPeriodicExpense.ts | 9 + .../handlers/createPeriodicExpense.ts | 9 + .../handlers/generateMonthlyExpense.ts | 8 + .../modules/expenses/handlers/listExpenses.ts | 8 + .../expenses/handlers/listPeriodicExpenses.ts | 7 + .../modules/expenses/handlers/payExpense.ts | 10 + .../handlers/softDeletePeriodicExpense.ts | 8 + .../handlers/updatePeriodicExpense.ts | 10 + apps/backend/tests/expenses.test.ts | 450 + .../.vite/deps/@tanstack_react-router.js | 6 +- .../node_modules/.vite/deps/_metadata.json | 142 +- .../node_modules/.vite/deps/radix-ui.js | 8051 ++++------------- .../node_modules/.vite/deps/radix-ui.js.map | 8 +- .../node_modules/.vite/deps/recharts.js | 6 +- apps/frontend/package.json | 8 +- apps/frontend/src/components/ui/calendar.tsx | 87 + .../src/components/ui/date-picker.tsx | 62 + apps/frontend/src/components/ui/popover.tsx | 48 + .../src/components/ui/responsive-dialog.tsx | 225 + .../src/features/expenses/ExpensesPage.tsx | 45 +- .../features/expenses/ExpensesProvider.tsx | 120 + .../components/ExpensesTabContent.tsx | 60 + .../expenses/components/ExpensesTable.tsx | 142 + .../components/GenerateCurrentMonthDialog.tsx | 46 + .../expenses/components/NewExpenseDialog.tsx | 134 + .../expenses/components/PayExpenseDialog.tsx | 136 + .../components/PeriodicExpenseForm.tsx | 180 + .../components/PeriodicExpensesTabContent.tsx | 132 + .../components/PeriodicExpensesTable.tsx | 154 + apps/frontend/src/lib/api.ts | 90 + apps/frontend/src/lib/queries.ts | 95 +- bun.lockb | Bin 298040 -> 301000 bytes 39 files changed, 4338 insertions(+), 6435 deletions(-) create mode 100644 apps/backend/prisma/migrations/20260529122915_add_expenses/migration.sql create mode 100644 apps/backend/src/modules/expenses/expense.job.ts create mode 100644 apps/backend/src/modules/expenses/expenses.routes.ts create mode 100644 apps/backend/src/modules/expenses/expenses.service.ts create mode 100644 apps/backend/src/modules/expenses/handlers/createNonPeriodicExpense.ts create mode 100644 apps/backend/src/modules/expenses/handlers/createPeriodicExpense.ts create mode 100644 apps/backend/src/modules/expenses/handlers/generateMonthlyExpense.ts create mode 100644 apps/backend/src/modules/expenses/handlers/listExpenses.ts create mode 100644 apps/backend/src/modules/expenses/handlers/listPeriodicExpenses.ts create mode 100644 apps/backend/src/modules/expenses/handlers/payExpense.ts create mode 100644 apps/backend/src/modules/expenses/handlers/softDeletePeriodicExpense.ts create mode 100644 apps/backend/src/modules/expenses/handlers/updatePeriodicExpense.ts create mode 100644 apps/backend/tests/expenses.test.ts create mode 100644 apps/frontend/src/components/ui/calendar.tsx create mode 100644 apps/frontend/src/components/ui/date-picker.tsx create mode 100644 apps/frontend/src/components/ui/popover.tsx create mode 100644 apps/frontend/src/components/ui/responsive-dialog.tsx create mode 100644 apps/frontend/src/features/expenses/ExpensesProvider.tsx create mode 100644 apps/frontend/src/features/expenses/components/ExpensesTabContent.tsx create mode 100644 apps/frontend/src/features/expenses/components/ExpensesTable.tsx create mode 100644 apps/frontend/src/features/expenses/components/GenerateCurrentMonthDialog.tsx create mode 100644 apps/frontend/src/features/expenses/components/NewExpenseDialog.tsx create mode 100644 apps/frontend/src/features/expenses/components/PayExpenseDialog.tsx create mode 100644 apps/frontend/src/features/expenses/components/PeriodicExpenseForm.tsx create mode 100644 apps/frontend/src/features/expenses/components/PeriodicExpensesTabContent.tsx create mode 100644 apps/frontend/src/features/expenses/components/PeriodicExpensesTable.tsx diff --git a/apps/backend/package.json b/apps/backend/package.json index c838a0a..db9414c 100644 --- a/apps/backend/package.json +++ b/apps/backend/package.json @@ -18,7 +18,8 @@ "node-cron": "^4.2.1", "pg": "^8.21.0", "pino": "^10.3.1", - "pino-pretty": "^13.1.3" + "pino-pretty": "^13.1.3", + "zod": "^4.4.3" }, "prisma": { "seed": "bun run prisma/seed.ts" diff --git a/apps/backend/prisma/migrations/20260529122915_add_expenses/migration.sql b/apps/backend/prisma/migrations/20260529122915_add_expenses/migration.sql new file mode 100644 index 0000000..96f59f8 --- /dev/null +++ b/apps/backend/prisma/migrations/20260529122915_add_expenses/migration.sql @@ -0,0 +1,34 @@ +-- CreateEnum +CREATE TYPE "PaymentStatus" AS ENUM ('PENDING', 'PAYED'); + +-- CreateTable +CREATE TABLE "periodic_expenses" ( + "id" SERIAL NOT NULL, + "description" VARCHAR(50) NOT NULL, + "defaultDueDay" INTEGER NOT NULL, + "defaultAmount" MONEY NOT NULL, + "periods" INTEGER[], + "isDeleted" BOOLEAN NOT NULL DEFAULT false, + "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT "periodic_expenses_pkey" PRIMARY KEY ("id") +); + +-- CreateTable +CREATE TABLE "expenses" ( + "id" SERIAL NOT NULL, + "description" VARCHAR(50) NOT NULL, + "periodicExpenseId" INTEGER, + "year" INTEGER NOT NULL, + "month" INTEGER NOT NULL, + "amount" MONEY NOT NULL, + "amountPayed" MONEY, + "status" "PaymentStatus" NOT NULL DEFAULT 'PENDING', + "dueDate" TIMESTAMP(3) NOT NULL, + "paymentDate" TIMESTAMP(3), + + CONSTRAINT "expenses_pkey" PRIMARY KEY ("id") +); + +-- AddForeignKey +ALTER TABLE "expenses" ADD CONSTRAINT "expenses_periodicExpenseId_fkey" FOREIGN KEY ("periodicExpenseId") REFERENCES "periodic_expenses"("id") ON DELETE SET NULL ON UPDATE CASCADE; diff --git a/apps/backend/prisma/schema.prisma b/apps/backend/prisma/schema.prisma index f6572cb..13a0956 100644 --- a/apps/backend/prisma/schema.prisma +++ b/apps/backend/prisma/schema.prisma @@ -41,4 +41,41 @@ model QuoteHistory { type QuoteType @@map("quotes_history") +} + +// Expenses + +enum PaymentStatus { + PENDING + PAYED +} + +model PeriodicExpense { + id Int @id @default(autoincrement()) + description String @db.VarChar(50) + defaultDueDay Int + defaultAmount Decimal @db.Money + periods Int[] + isDeleted Boolean @default(false) + createdAt DateTime @default(now()) + + expenses Expense[] + + @@map("periodic_expenses") +} + +model Expense { + id Int @id @default(autoincrement()) + description String @db.VarChar(50) + periodicExpense PeriodicExpense? @relation(fields: [periodicExpenseId], references: [id]) + periodicExpenseId Int? + year Int + month Int + amount Decimal @db.Money + amountPayed Decimal? @db.Money + status PaymentStatus @default(PENDING) + dueDate DateTime + paymentDate DateTime? + + @@map("expenses") } \ No newline at end of file diff --git a/apps/backend/src/index.ts b/apps/backend/src/index.ts index e35a5d1..0a2c528 100644 --- a/apps/backend/src/index.ts +++ b/apps/backend/src/index.ts @@ -2,6 +2,8 @@ import { Hono } from "hono"; import { serveStatic } from "hono/bun"; import { startQuoteJob } from "./modules/quotes/quote.job"; import quotesRouter from "./modules/quotes/quotes.routes"; +import expensesRouter from "./modules/expenses/expenses.routes"; +import { startExpenseJob } from "./modules/expenses/expense.job"; import { logger } from "./lib/logger"; const app = new Hono(); @@ -11,11 +13,13 @@ app.get("/api/health", (c) => { }); app.route("/api/quotes", quotesRouter); +app.route("/api", expensesRouter); app.use("/assets/*", serveStatic({ root: "./web" })); app.get("*", serveStatic({ path: "./web/index.html" })); startQuoteJob(); +startExpenseJob(); logger.info("Backend started"); diff --git a/apps/backend/src/modules/expenses/expense.job.ts b/apps/backend/src/modules/expenses/expense.job.ts new file mode 100644 index 0000000..e75e2f1 --- /dev/null +++ b/apps/backend/src/modules/expenses/expense.job.ts @@ -0,0 +1,16 @@ +import cron from "node-cron"; +import { logger } from "../../lib/logger"; +import { generateExpensesForCurrentMonth } from "./expenses.service"; + +export function startExpenseJob(): void { + cron.schedule("0 1 1 * *", async () => { + logger.info("Generating monthly expenses..."); + try { + const results = await generateExpensesForCurrentMonth(); + logger.info({ results }, "Monthly expenses generated"); + } catch (err) { + logger.error({ err }, "Failed to generate monthly expenses"); + } + }); + logger.info("Expense cron scheduled: 0 1 1 * *"); +} diff --git a/apps/backend/src/modules/expenses/expenses.routes.ts b/apps/backend/src/modules/expenses/expenses.routes.ts new file mode 100644 index 0000000..80472a3 --- /dev/null +++ b/apps/backend/src/modules/expenses/expenses.routes.ts @@ -0,0 +1,23 @@ +import { Hono } from "hono"; +import { createPeriodicExpenseHandler } from "./handlers/createPeriodicExpense"; +import { listPeriodicExpensesHandler } from "./handlers/listPeriodicExpenses"; +import { updatePeriodicExpenseHandler } from "./handlers/updatePeriodicExpense"; +import { softDeletePeriodicExpenseHandler } from "./handlers/softDeletePeriodicExpense"; +import { generateMonthlyExpenseHandler } from "./handlers/generateMonthlyExpense"; +import { listExpensesHandler } from "./handlers/listExpenses"; +import { createNonPeriodicExpenseHandler } from "./handlers/createNonPeriodicExpense"; +import { payExpenseHandler } from "./handlers/payExpense"; + +const app = new Hono(); + +app.get("/periodic-expenses", listPeriodicExpensesHandler); +app.post("/periodic-expenses", createPeriodicExpenseHandler); +app.put("/periodic-expenses/:id", updatePeriodicExpenseHandler); +app.delete("/periodic-expenses/:id", softDeletePeriodicExpenseHandler); +app.post("/periodic-expenses/:id/generate-month", generateMonthlyExpenseHandler); + +app.get("/expenses", listExpensesHandler); +app.post("/expenses", createNonPeriodicExpenseHandler); +app.put("/expenses/:id/pay", payExpenseHandler); + +export default app; diff --git a/apps/backend/src/modules/expenses/expenses.service.ts b/apps/backend/src/modules/expenses/expenses.service.ts new file mode 100644 index 0000000..cb55f43 --- /dev/null +++ b/apps/backend/src/modules/expenses/expenses.service.ts @@ -0,0 +1,160 @@ +import { z } from "zod"; +import { prisma } from "../../lib/prisma"; +import { PaymentStatus } from "../../generated/prisma/client"; + +export const createPeriodicExpenseSchema = z.object({ + description: z.string().min(1).max(50), + defaultDueDay: z.number().int().min(1).max(31), + defaultAmount: z.number().positive(), + periods: z.array(z.number().int().min(1).max(12)).min(1), +}); + +export const updatePeriodicExpenseSchema = createPeriodicExpenseSchema; + +export const createNonPeriodicExpenseSchema = z.object({ + description: z.string().min(1).max(50), + amount: z.number().positive(), + dueDate: z.string().datetime(), +}); + +export const payExpenseSchema = z.object({ + amountPayed: z.number().positive(), + paymentDate: z.string().datetime().optional(), +}); + +function lastDayOfMonth(year: number, month: number): number { + return new Date(year, month, 0).getDate(); +} + +export function buildDueDate(year: number, month: number, dueDay: number): Date { + const clampedDay = Math.min(dueDay, lastDayOfMonth(year, month)); + return new Date(Date.UTC(year, month - 1, clampedDay, 0, 0, 0, 0)); +} + +export function getCurrentYearMonthUTC(): { year: number; month: number } { + const now = new Date(); + return { year: now.getUTCFullYear(), month: now.getUTCMonth() + 1 }; +} + +export async function listPeriodicExpenses() { + return prisma.periodicExpense.findMany({ + where: { isDeleted: false }, + orderBy: { createdAt: "desc" }, + }); +} + +export async function createPeriodicExpense(data: z.infer) { + const result = await prisma.periodicExpense.create({ data }); + const { year, month } = getCurrentYearMonthUTC(); + const currentMonthApplicable = data.periods.includes(month); + return { ...result, currentMonthApplicable }; +} + +export async function updatePeriodicExpense(id: number, data: z.infer) { + return prisma.periodicExpense.update({ where: { id }, data }); +} + +export async function softDeletePeriodicExpense(id: number) { + return prisma.periodicExpense.update({ + where: { id }, + data: { isDeleted: true }, + }); +} + +export async function generateMonthlyExpense(id: number) { + const periodic = await prisma.periodicExpense.findUniqueOrThrow({ where: { id } }); + const { year, month } = getCurrentYearMonthUTC(); + + const existing = await prisma.expense.findFirst({ + where: { periodicExpenseId: id, year, month }, + }); + if (existing) return existing; + + const dueDate = buildDueDate(year, month, periodic.defaultDueDay); + return prisma.expense.create({ + data: { + description: periodic.description, + periodicExpenseId: id, + year, + month, + amount: periodic.defaultAmount, + dueDate, + status: PaymentStatus.PENDING, + }, + }); +} + +export async function listExpenses(status?: string) { + const where: Record = {}; + if (status === "PENDING" || status === "PAYED") { + where.status = status; + } + return prisma.expense.findMany({ + where, + include: { periodicExpense: true }, + orderBy: { dueDate: "asc" }, + }); +} + +export async function createNonPeriodicExpense(data: z.infer) { + const dueDate = new Date(data.dueDate); + const year = dueDate.getUTCFullYear(); + const month = dueDate.getUTCMonth() + 1; + return prisma.expense.create({ + data: { + description: data.description, + amount: data.amount, + amountPayed: data.amount, + dueDate, + paymentDate: dueDate, + year, + month, + status: PaymentStatus.PAYED, + }, + }); +} + +export async function payExpense(id: number, data: z.infer) { + const paymentDate = data.paymentDate ? new Date(data.paymentDate) : new Date(); + return prisma.expense.update({ + where: { id }, + data: { + status: PaymentStatus.PAYED, + amountPayed: data.amountPayed, + paymentDate, + }, + }); +} + +export async function generateExpensesForCurrentMonth() { + const { year, month } = getCurrentYearMonthUTC(); + + const periodics = await prisma.periodicExpense.findMany({ + where: { isDeleted: false, periods: { has: month } }, + }); + + const results: Array<{ id: number; status: string }> = []; + for (const periodic of periodics) { + const existing = await prisma.expense.findFirst({ + where: { periodicExpenseId: periodic.id, year, month }, + }); + if (existing) { + results.push({ id: periodic.id, status: "already_exists" }); + continue; + } + const dueDate = buildDueDate(year, month, periodic.defaultDueDay); + await prisma.expense.create({ + data: { + description: periodic.description, + periodicExpenseId: periodic.id, + year, + month, + amount: periodic.defaultAmount, + dueDate, + status: PaymentStatus.PENDING, + }, + }); + results.push({ id: periodic.id, status: "created" }); + } + return results; +} diff --git a/apps/backend/src/modules/expenses/handlers/createNonPeriodicExpense.ts b/apps/backend/src/modules/expenses/handlers/createNonPeriodicExpense.ts new file mode 100644 index 0000000..f319c45 --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/createNonPeriodicExpense.ts @@ -0,0 +1,9 @@ +import type { Context } from "hono"; +import { createNonPeriodicExpense, createNonPeriodicExpenseSchema } from "../expenses.service"; + +export async function createNonPeriodicExpenseHandler(c: Context) { + const body = await c.req.json(); + const parsed = createNonPeriodicExpenseSchema.parse(body); + const result = await createNonPeriodicExpense(parsed); + return c.json(result, 201); +} diff --git a/apps/backend/src/modules/expenses/handlers/createPeriodicExpense.ts b/apps/backend/src/modules/expenses/handlers/createPeriodicExpense.ts new file mode 100644 index 0000000..446cc03 --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/createPeriodicExpense.ts @@ -0,0 +1,9 @@ +import type { Context } from "hono"; +import { createPeriodicExpense, createPeriodicExpenseSchema } from "../expenses.service"; + +export async function createPeriodicExpenseHandler(c: Context) { + const body = await c.req.json(); + const parsed = createPeriodicExpenseSchema.parse(body); + const result = await createPeriodicExpense(parsed); + return c.json(result, 201); +} diff --git a/apps/backend/src/modules/expenses/handlers/generateMonthlyExpense.ts b/apps/backend/src/modules/expenses/handlers/generateMonthlyExpense.ts new file mode 100644 index 0000000..9fb4975 --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/generateMonthlyExpense.ts @@ -0,0 +1,8 @@ +import type { Context } from "hono"; +import { generateMonthlyExpense } from "../expenses.service"; + +export async function generateMonthlyExpenseHandler(c: Context) { + const id = Number(c.req.param("id")); + const result = await generateMonthlyExpense(id); + return c.json(result); +} diff --git a/apps/backend/src/modules/expenses/handlers/listExpenses.ts b/apps/backend/src/modules/expenses/handlers/listExpenses.ts new file mode 100644 index 0000000..2926dc4 --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/listExpenses.ts @@ -0,0 +1,8 @@ +import type { Context } from "hono"; +import { listExpenses } from "../expenses.service"; + +export async function listExpensesHandler(c: Context) { + const status = c.req.query("status"); + const expenses = await listExpenses(status); + return c.json(expenses); +} diff --git a/apps/backend/src/modules/expenses/handlers/listPeriodicExpenses.ts b/apps/backend/src/modules/expenses/handlers/listPeriodicExpenses.ts new file mode 100644 index 0000000..588cc4f --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/listPeriodicExpenses.ts @@ -0,0 +1,7 @@ +import type { Context } from "hono"; +import { listPeriodicExpenses } from "../expenses.service"; + +export async function listPeriodicExpensesHandler(c: Context) { + const expenses = await listPeriodicExpenses(); + return c.json(expenses); +} diff --git a/apps/backend/src/modules/expenses/handlers/payExpense.ts b/apps/backend/src/modules/expenses/handlers/payExpense.ts new file mode 100644 index 0000000..91e05d7 --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/payExpense.ts @@ -0,0 +1,10 @@ +import type { Context } from "hono"; +import { payExpense, payExpenseSchema } from "../expenses.service"; + +export async function payExpenseHandler(c: Context) { + const id = Number(c.req.param("id")); + const body = await c.req.json(); + const parsed = payExpenseSchema.parse(body); + const result = await payExpense(id, parsed); + return c.json(result); +} diff --git a/apps/backend/src/modules/expenses/handlers/softDeletePeriodicExpense.ts b/apps/backend/src/modules/expenses/handlers/softDeletePeriodicExpense.ts new file mode 100644 index 0000000..3c8d73f --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/softDeletePeriodicExpense.ts @@ -0,0 +1,8 @@ +import type { Context } from "hono"; +import { softDeletePeriodicExpense } from "../expenses.service"; + +export async function softDeletePeriodicExpenseHandler(c: Context) { + const id = Number(c.req.param("id")); + await softDeletePeriodicExpense(id); + return c.json({ success: true }); +} diff --git a/apps/backend/src/modules/expenses/handlers/updatePeriodicExpense.ts b/apps/backend/src/modules/expenses/handlers/updatePeriodicExpense.ts new file mode 100644 index 0000000..ad29cb0 --- /dev/null +++ b/apps/backend/src/modules/expenses/handlers/updatePeriodicExpense.ts @@ -0,0 +1,10 @@ +import type { Context } from "hono"; +import { updatePeriodicExpense, updatePeriodicExpenseSchema } from "../expenses.service"; + +export async function updatePeriodicExpenseHandler(c: Context) { + const id = Number(c.req.param("id")); + const body = await c.req.json(); + const parsed = updatePeriodicExpenseSchema.parse(body); + const result = await updatePeriodicExpense(id, parsed); + return c.json(result); +} diff --git a/apps/backend/tests/expenses.test.ts b/apps/backend/tests/expenses.test.ts new file mode 100644 index 0000000..fb59823 --- /dev/null +++ b/apps/backend/tests/expenses.test.ts @@ -0,0 +1,450 @@ +import { describe, test, expect, mock, beforeEach } from "bun:test"; +import { PaymentStatus } from "../src/generated/prisma/client"; + +const mockPrisma = { + periodicExpense: { + findMany: mock(), + findUniqueOrThrow: mock(), + create: mock(), + update: mock(), + }, + expense: { + findMany: mock(), + findFirst: mock(), + create: mock(), + update: mock(), + }, +}; + +mock.module("../src/lib/prisma", () => ({ + prisma: mockPrisma, +})); + +beforeEach(() => { + for (const model of Object.values(mockPrisma)) { + for (const fn of Object.values(model as Record>)) { + fn.mockClear(); + } + } +}); + +const { + createPeriodicExpenseSchema, + updatePeriodicExpenseSchema, + createNonPeriodicExpenseSchema, + payExpenseSchema, + buildDueDate, + getCurrentYearMonthUTC, + listPeriodicExpenses, + createPeriodicExpense, + updatePeriodicExpense, + softDeletePeriodicExpense, + listExpenses, + createNonPeriodicExpense, + payExpense, + generateExpensesForCurrentMonth, + generateMonthlyExpense, +} = await import("../src/modules/expenses/expenses.service"); + +describe("schemas", () => { + describe("createPeriodicExpenseSchema", () => { + test("accepts valid input", () => { + const result = createPeriodicExpenseSchema.parse({ + description: "Gimnasio", + defaultDueDay: 10, + defaultAmount: 1500.50, + periods: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], + }); + expect(result.description).toBe("Gimnasio"); + }); + + test("rejects empty description", () => { + expect(() => + createPeriodicExpenseSchema.parse({ + description: "", + defaultDueDay: 10, + defaultAmount: 100, + periods: [1], + }) + ).toThrow(); + }); + + test("rejects description over 50 chars", () => { + expect(() => + createPeriodicExpenseSchema.parse({ + description: "a".repeat(51), + defaultDueDay: 10, + defaultAmount: 100, + periods: [1], + }) + ).toThrow(); + }); + + test("rejects due day < 1", () => { + expect(() => + createPeriodicExpenseSchema.parse({ + description: "Test", + defaultDueDay: 0, + defaultAmount: 100, + periods: [1], + }) + ).toThrow(); + }); + + test("rejects due day > 31", () => { + expect(() => + createPeriodicExpenseSchema.parse({ + description: "Test", + defaultDueDay: 32, + defaultAmount: 100, + periods: [1], + }) + ).toThrow(); + }); + + test("rejects non-positive amount", () => { + expect(() => + createPeriodicExpenseSchema.parse({ + description: "Test", + defaultDueDay: 15, + defaultAmount: 0, + periods: [1], + }) + ).toThrow(); + }); + + test("rejects empty periods", () => { + expect(() => + createPeriodicExpenseSchema.parse({ + description: "Test", + defaultDueDay: 15, + defaultAmount: 100, + periods: [], + }) + ).toThrow(); + }); + + test("rejects invalid period month", () => { + expect(() => + createPeriodicExpenseSchema.parse({ + description: "Test", + defaultDueDay: 15, + defaultAmount: 100, + periods: [0, 13], + }) + ).toThrow(); + }); + }); + + describe("createNonPeriodicExpenseSchema", () => { + test("accepts valid input", () => { + const result = createNonPeriodicExpenseSchema.parse({ + description: "Ropa", + amount: 2500, + dueDate: "2026-06-15T00:00:00.000Z", + }); + expect(result.description).toBe("Ropa"); + }); + + test("rejects negative amount", () => { + expect(() => + createNonPeriodicExpenseSchema.parse({ + description: "Ropa", + amount: -100, + dueDate: "2026-06-15T00:00:00.000Z", + }) + ).toThrow(); + }); + }); + + describe("payExpenseSchema", () => { + test("accepts valid payment", () => { + const result = payExpenseSchema.parse({ + amountPayed: 1400, + paymentDate: "2026-06-10T00:00:00.000Z", + }); + expect(result.amountPayed).toBe(1400); + }); + + test("allows missing paymentDate", () => { + const result = payExpenseSchema.parse({ amountPayed: 1400 }); + expect(result.amountPayed).toBe(1400); + expect(result.paymentDate).toBeUndefined(); + }); + + test("rejects zero amountPayed", () => { + expect(() => + payExpenseSchema.parse({ amountPayed: 0 }) + ).toThrow(); + }); + }); +}); + +describe("buildDueDate", () => { + test("creates valid date", () => { + const date = buildDueDate(2026, 6, 15); + expect(date.getUTCFullYear()).toBe(2026); + expect(date.getUTCMonth()).toBe(5); // 0-indexed + expect(date.getUTCDate()).toBe(15); + }); + + test("clamps day to last day of month when dueDay exceeds month length", () => { + const date = buildDueDate(2026, 2, 31); + expect(date.getUTCMonth()).toBe(1); // February (0-indexed) + expect(date.getUTCDate()).toBe(28); + }); + + test("handles december correctly", () => { + const date = buildDueDate(2026, 12, 31); + expect(date.getUTCFullYear()).toBe(2026); + expect(date.getUTCMonth()).toBe(11); + expect(date.getUTCDate()).toBe(31); + }); + + test("handles leap year february", () => { + const date = buildDueDate(2024, 2, 29); + expect(date.getUTCFullYear()).toBe(2024); + expect(date.getUTCMonth()).toBe(1); + expect(date.getUTCDate()).toBe(29); + }); +}); + +describe("getCurrentYearMonthUTC", () => { + test("returns valid year and month", () => { + const { year, month } = getCurrentYearMonthUTC(); + expect(year).toBeGreaterThan(2020); + expect(month).toBeGreaterThanOrEqual(1); + expect(month).toBeLessThanOrEqual(12); + }); +}); + +describe("listPeriodicExpenses", () => { + test("returns only non-deleted expenses ordered by createdAt desc", async () => { + const mockItems = [ + { id: 1, description: "Gas", isDeleted: false, createdAt: new Date() }, + ]; + mockPrisma.periodicExpense.findMany.mockResolvedValueOnce(mockItems); + + const result = await listPeriodicExpenses(); + expect(result).toEqual(mockItems); + expect(mockPrisma.periodicExpense.findMany).toHaveBeenCalledWith({ + where: { isDeleted: false }, + orderBy: { createdAt: "desc" }, + }); + }); +}); + +describe("createPeriodicExpense", () => { + test("creates and detects current month applicability", async () => { + const input = { + description: "Gimnasio", + defaultDueDay: 10, + defaultAmount: 1500, + periods: [6], + }; + const created = { id: 1, ...input, isDeleted: false, createdAt: new Date() }; + mockPrisma.periodicExpense.create.mockResolvedValueOnce(created); + + const result = await createPeriodicExpense(input); + expect(result.id).toBe(1); + // currentMonthApplicable depends on actual month; just verify truthy/falsy + expect("currentMonthApplicable" in result).toBe(true); + }); +}); + +describe("updatePeriodicExpense", () => { + test("updates and returns the record", async () => { + const input = { + description: "Gas actualizado", + defaultDueDay: 5, + defaultAmount: 2000, + periods: [1, 7], + }; + const updated = { id: 1, ...input, isDeleted: false }; + mockPrisma.periodicExpense.update.mockResolvedValueOnce(updated); + + const result = await updatePeriodicExpense(1, input); + expect(result.description).toBe("Gas actualizado"); + expect(mockPrisma.periodicExpense.update).toHaveBeenCalledWith({ + where: { id: 1 }, + data: input, + }); + }); +}); + +describe("softDeletePeriodicExpense", () => { + test("sets isDeleted to true", async () => { + const deleted = { id: 1, isDeleted: true }; + mockPrisma.periodicExpense.update.mockResolvedValueOnce(deleted); + + const result = await softDeletePeriodicExpense(1); + expect(result.isDeleted).toBe(true); + expect(mockPrisma.periodicExpense.update).toHaveBeenCalledWith({ + where: { id: 1 }, + data: { isDeleted: true }, + }); + }); +}); + +describe("listExpenses", () => { + test("returns all expenses when no status filter", async () => { + mockPrisma.expense.findMany.mockResolvedValueOnce([]); + await listExpenses(); + expect(mockPrisma.expense.findMany).toHaveBeenCalledWith({ + where: {}, + include: { periodicExpense: true }, + orderBy: { dueDate: "asc" }, + }); + }); + + test("filters by status when provided", async () => { + mockPrisma.expense.findMany.mockResolvedValueOnce([]); + await listExpenses("PENDING"); + expect(mockPrisma.expense.findMany).toHaveBeenCalledWith({ + where: { status: "PENDING" }, + include: { periodicExpense: true }, + orderBy: { dueDate: "asc" }, + }); + }); +}); + +describe("createNonPeriodicExpense", () => { + test("creates expense with PAYED status and sets amountPayed", async () => { + const input = { + description: "Ropa", + amount: 2500, + dueDate: "2026-06-15T00:00:00.000Z", + }; + const created = { + id: 1, + description: "Ropa", + amount: 2500, + amountPayed: 2500, + status: PaymentStatus.PAYED, + year: 2026, + month: 6, + }; + mockPrisma.expense.create.mockResolvedValueOnce(created); + + const result = await createNonPeriodicExpense(input); + expect(result.status).toBe(PaymentStatus.PAYED); + expect(result.amountPayed).toBe(2500); + expect(mockPrisma.expense.create).toHaveBeenCalledWith({ + data: expect.objectContaining({ + description: "Ropa", + amount: 2500, + amountPayed: 2500, + status: PaymentStatus.PAYED, + paymentDate: expect.any(Date), + }), + }); + }); +}); + +describe("payExpense", () => { + test("updates status to PAYED with amountPayed and paymentDate", async () => { + const paidExpense = { + id: 1, + status: PaymentStatus.PAYED, + amountPayed: 1400, + paymentDate: new Date("2026-06-10T00:00:00.000Z"), + }; + mockPrisma.expense.update.mockResolvedValueOnce(paidExpense); + + const result = await payExpense(1, { + amountPayed: 1400, + paymentDate: "2026-06-10T00:00:00.000Z", + }); + expect(result.status).toBe(PaymentStatus.PAYED); + expect(result.amountPayed).toBe(1400); + }); + + test("defaults paymentDate to now when not provided", async () => { + mockPrisma.expense.update.mockImplementationOnce(async ({ where, data }) => ({ + id: where.id, + ...data, + status: PaymentStatus.PAYED, + amountPayed: data.amountPayed, + paymentDate: data.paymentDate, + })); + + const result = await payExpense(1, { amountPayed: 1500 }); + expect(result.status).toBe(PaymentStatus.PAYED); + expect(result.paymentDate).toBeInstanceOf(Date); + }); +}); + +describe("generateExpensesForCurrentMonth", () => { + test("skips existing expenses to avoid duplicates", async () => { + const { month } = getCurrentYearMonthUTC(); + mockPrisma.periodicExpense.findMany.mockResolvedValueOnce([ + { id: 1, description: "Gas", defaultDueDay: 15, defaultAmount: 2000, periods: [month] }, + ]); + mockPrisma.expense.findFirst.mockResolvedValueOnce({ id: 99 }); + + const results = await generateExpensesForCurrentMonth(); + expect(results).toHaveLength(1); + expect(results[0].status).toBe("already_exists"); + expect(mockPrisma.expense.create).not.toHaveBeenCalled(); + }); + + test("creates expenses for applicable periodic expenses", async () => { + const { month } = getCurrentYearMonthUTC(); + const periodic = { + id: 1, + description: "Gas", + defaultDueDay: 15, + defaultAmount: 2000, + periods: [month], + }; + mockPrisma.periodicExpense.findMany.mockResolvedValueOnce([periodic]); + mockPrisma.expense.findFirst.mockResolvedValueOnce(null); + mockPrisma.expense.create.mockResolvedValueOnce({ + id: 1, + description: "Gas", + periodicExpenseId: 1, + amount: 2000, + status: "PENDING", + }); + + const results = await generateExpensesForCurrentMonth(); + expect(results).toHaveLength(1); + expect(results[0].status).toBe("created"); + }); + + test("ignores deleted periodic expenses", async () => { + mockPrisma.periodicExpense.findMany.mockResolvedValueOnce([]); + + const results = await generateExpensesForCurrentMonth(); + expect(results).toHaveLength(0); + expect(mockPrisma.periodicExpense.findMany).toHaveBeenCalledWith({ + where: { isDeleted: false, periods: { has: expect.any(Number) } }, + }); + }); +}); + +describe("generateMonthlyExpense", () => { + test("creates expense for given periodic expense", async () => { + const periodic = { id: 1, description: "Gas", defaultDueDay: 15, defaultAmount: 2000, periods: [6] }; + mockPrisma.periodicExpense.findUniqueOrThrow.mockResolvedValueOnce(periodic); + mockPrisma.expense.findFirst.mockResolvedValueOnce(null); + mockPrisma.expense.create.mockResolvedValueOnce({ + id: 1, description: "Gas", periodicExpenseId: 1, amount: 2000, status: "PENDING", + }); + + const result = await generateMonthlyExpense(1); + expect(result.id).toBe(1); + }); + + test("returns existing expense instead of duplicating", async () => { + const existing = { id: 99, description: "Gas", periodicExpenseId: 1 }; + mockPrisma.periodicExpense.findUniqueOrThrow.mockResolvedValueOnce({ + id: 1, description: "Gas", defaultDueDay: 15, defaultAmount: 2000, periods: [6], + }); + mockPrisma.expense.findFirst.mockResolvedValueOnce(existing); + + const result = await generateMonthlyExpense(1); + expect(result.id).toBe(99); + expect(result).toEqual(existing); + }); +}); diff --git a/apps/frontend/node_modules/.vite/deps/@tanstack_react-router.js b/apps/frontend/node_modules/.vite/deps/@tanstack_react-router.js index 384e4af..964e63e 100644 --- a/apps/frontend/node_modules/.vite/deps/@tanstack_react-router.js +++ b/apps/frontend/node_modules/.vite/deps/@tanstack_react-router.js @@ -3,12 +3,12 @@ import { require_with_selector } from "./chunk-NMJBVCD2.js"; import "./chunk-X37QSMNJ.js"; -import { - require_react_dom -} from "./chunk-JCMTJHXH.js"; import { require_jsx_runtime } from "./chunk-SOQCU2R6.js"; +import { + require_react_dom +} from "./chunk-JCMTJHXH.js"; import { require_react } from "./chunk-6VO5C3OI.js"; diff --git a/apps/frontend/node_modules/.vite/deps/_metadata.json b/apps/frontend/node_modules/.vite/deps/_metadata.json index f9da9e8..37babee 100644 --- a/apps/frontend/node_modules/.vite/deps/_metadata.json +++ b/apps/frontend/node_modules/.vite/deps/_metadata.json @@ -1,128 +1,206 @@ { - "hash": "5f00aae5", + "hash": "3d534d7c", "configHash": "c0c89d92", - "lockfileHash": "9500aa13", - "browserHash": "efa9b066", + "lockfileHash": "e6e58bf9", + "browserHash": "5ec6480f", "optimized": { "react": { "src": "../../../../../node_modules/react/index.js", "file": "react.js", - "fileHash": "98e991e0", + "fileHash": "fcd31548", "needsInterop": true }, "react-dom": { "src": "../../../../../node_modules/react-dom/index.js", "file": "react-dom.js", - "fileHash": "3b7ba340", + "fileHash": "ab67f690", "needsInterop": true }, "react/jsx-dev-runtime": { "src": "../../../../../node_modules/react/jsx-dev-runtime.js", "file": "react_jsx-dev-runtime.js", - "fileHash": "8b662de2", + "fileHash": "138cab66", "needsInterop": true }, "react/jsx-runtime": { "src": "../../../../../node_modules/react/jsx-runtime.js", "file": "react_jsx-runtime.js", - "fileHash": "edbd65cc", + "fileHash": "9805fa83", "needsInterop": true }, + "@hookform/resolvers/zod": { + "src": "../../../../../node_modules/@hookform/resolvers/zod/dist/zod.mjs", + "file": "@hookform_resolvers_zod.js", + "fileHash": "194b2aaa", + "needsInterop": false + }, + "@radix-ui/react-dialog": { + "src": "../../../../../node_modules/@radix-ui/react-dialog/dist/index.mjs", + "file": "@radix-ui_react-dialog.js", + "fileHash": "a148c7fe", + "needsInterop": false + }, "@tanstack/react-query": { "src": "../../../../../node_modules/@tanstack/react-query/build/modern/index.js", "file": "@tanstack_react-query.js", - "fileHash": "705b896d", + "fileHash": "ffafe25c", "needsInterop": false }, "@tanstack/react-query-devtools": { "src": "../../../../../node_modules/@tanstack/react-query-devtools/build/modern/index.js", "file": "@tanstack_react-query-devtools.js", - "fileHash": "70485a02", + "fileHash": "f836306e", "needsInterop": false }, "@tanstack/react-router": { "src": "../../../../../node_modules/@tanstack/react-router/dist/esm/index.dev.js", "file": "@tanstack_react-router.js", - "fileHash": "141b1c82", + "fileHash": "5e18d809", + "needsInterop": false + }, + "@tanstack/react-table": { + "src": "../../../../../node_modules/@tanstack/react-table/build/lib/index.mjs", + "file": "@tanstack_react-table.js", + "fileHash": "de1dde72", "needsInterop": false }, "class-variance-authority": { "src": "../../../../../node_modules/class-variance-authority/dist/index.mjs", "file": "class-variance-authority.js", - "fileHash": "6c7abe67", + "fileHash": "79ca80ed", "needsInterop": false }, "clsx": { "src": "../../../../../node_modules/clsx/dist/clsx.mjs", "file": "clsx.js", - "fileHash": "97c8d984", + "fileHash": "560d7dff", "needsInterop": false }, "lucide-react": { "src": "../../../../../node_modules/lucide-react/dist/esm/lucide-react.mjs", "file": "lucide-react.js", - "fileHash": "ad567fd3", + "fileHash": "27bd6cb0", "needsInterop": false }, "radix-ui": { "src": "../../../../../node_modules/radix-ui/dist/index.mjs", "file": "radix-ui.js", - "fileHash": "10864bf0", + "fileHash": "f216ffc2", "needsInterop": false }, "react-dom/client": { "src": "../../../../../node_modules/react-dom/client.js", "file": "react-dom_client.js", - "fileHash": "ab77e82f", + "fileHash": "a87aab08", "needsInterop": true }, + "react-hook-form": { + "src": "../../../../../node_modules/react-hook-form/dist/index.esm.mjs", + "file": "react-hook-form.js", + "fileHash": "72222317", + "needsInterop": false + }, "recharts": { "src": "../../../../../node_modules/recharts/es6/index.js", "file": "recharts.js", - "fileHash": "d0cc5258", + "fileHash": "de40db9e", "needsInterop": false }, "tailwind-merge": { "src": "../../../../../node_modules/tailwind-merge/dist/bundle-mjs.mjs", "file": "tailwind-merge.js", - "fileHash": "f48a862a", + "fileHash": "d68cea17", + "needsInterop": false + }, + "zod": { + "src": "../../../../../node_modules/zod/index.js", + "file": "zod.js", + "fileHash": "c1ae98b2", + "needsInterop": false + }, + "date-fns": { + "src": "../../../../../node_modules/date-fns/index.js", + "file": "date-fns.js", + "fileHash": "5586195a", + "needsInterop": false + }, + "date-fns/locale": { + "src": "../../../../../node_modules/date-fns/locale.js", + "file": "date-fns_locale.js", + "fileHash": "78139fca", + "needsInterop": false + }, + "@radix-ui/react-popover": { + "src": "../../../../../node_modules/@radix-ui/react-popover/dist/index.mjs", + "file": "@radix-ui_react-popover.js", + "fileHash": "1a4bc9a8", + "needsInterop": false + }, + "react-day-picker": { + "src": "../../../../../node_modules/react-day-picker/dist/esm/index.js", + "file": "react-day-picker.js", + "fileHash": "a6f8a45a", "needsInterop": false } }, "chunks": { + "ZUJJ2RGI-GFZTQM7R": { + "file": "ZUJJ2RGI-GFZTQM7R.js" + }, + "VKXKX7EQ-FAVAKZBN": { + "file": "VKXKX7EQ-FAVAKZBN.js" + }, + "chunk-LSVH5W4R": { + "file": "chunk-LSVH5W4R.js" + }, + "chunk-G4FIB5Z7": { + "file": "chunk-G4FIB5Z7.js" + }, + "chunk-6US6M7KI": { + "file": "chunk-6US6M7KI.js" + }, + "chunk-TLZOGT6B": { + "file": "chunk-TLZOGT6B.js" + }, + "chunk-O6J3DKHL": { + "file": "chunk-O6J3DKHL.js" + }, + "chunk-A2TD7EYA": { + "file": "chunk-A2TD7EYA.js" + }, "chunk-NMJBVCD2": { "file": "chunk-NMJBVCD2.js" }, "chunk-X37QSMNJ": { "file": "chunk-X37QSMNJ.js" }, - "VKXKX7EQ-FAVAKZBN": { - "file": "VKXKX7EQ-FAVAKZBN.js" + "chunk-WFNHCR67": { + "file": "chunk-WFNHCR67.js" }, - "ZUJJ2RGI-GFZTQM7R": { - "file": "ZUJJ2RGI-GFZTQM7R.js" + "chunk-R6CVIFUM": { + "file": "chunk-R6CVIFUM.js" }, - "chunk-LSVH5W4R": { - "file": "chunk-LSVH5W4R.js" + "chunk-2EY3U74L": { + "file": "chunk-2EY3U74L.js" }, - "chunk-JCMTJHXH": { - "file": "chunk-JCMTJHXH.js" + "chunk-TYPHK3K7": { + "file": "chunk-TYPHK3K7.js" }, - "chunk-TLZOGT6B": { - "file": "chunk-TLZOGT6B.js" + "chunk-ITOVD2G7": { + "file": "chunk-ITOVD2G7.js" }, - "chunk-A2TD7EYA": { - "file": "chunk-A2TD7EYA.js" + "chunk-OAGFOHTQ": { + "file": "chunk-OAGFOHTQ.js" }, "chunk-SOQCU2R6": { "file": "chunk-SOQCU2R6.js" }, + "chunk-JCMTJHXH": { + "file": "chunk-JCMTJHXH.js" + }, "chunk-6VO5C3OI": { "file": "chunk-6VO5C3OI.js" }, - "chunk-WFNHCR67": { - "file": "chunk-WFNHCR67.js" - }, "chunk-WOOG5QLI": { "file": "chunk-WOOG5QLI.js" } diff --git a/apps/frontend/node_modules/.vite/deps/radix-ui.js b/apps/frontend/node_modules/.vite/deps/radix-ui.js index 0ea65bc..6c54bf7 100644 --- a/apps/frontend/node_modules/.vite/deps/radix-ui.js +++ b/apps/frontend/node_modules/.vite/deps/radix-ui.js @@ -1,12 +1,61 @@ +import { + Close, + Content as Content2, + Description, + Overlay, + Portal as Portal2, + Root as Root3, + Title, + Trigger, + WarningProvider, + createDialogScope, + dist_exports as dist_exports4 +} from "./chunk-O6J3DKHL.js"; import { require_shim } from "./chunk-X37QSMNJ.js"; import { - require_react_dom -} from "./chunk-JCMTJHXH.js"; + Anchor, + Arrow, + Content, + Root2 as Root22, + createPopperScope, + dist_exports as dist_exports3, + useSize +} from "./chunk-R6CVIFUM.js"; +import { + Branch, + Combination_default, + DismissableLayer, + FocusScope, + Portal, + Presence, + Primitive, + Root, + Root2, + composeEventHandlers, + composeRefs, + createContextScope, + createSlot, + createSlottable, + dispatchDiscreteCustomEvent, + dist_exports, + dist_exports2, + hideOthers, + useCallbackRef, + useComposedRefs, + useControllableState, + useEffectEvent, + useFocusGuards, + useId, + useLayoutEffect2 +} from "./chunk-2EY3U74L.js"; import { require_jsx_runtime } from "./chunk-SOQCU2R6.js"; +import { + require_react_dom +} from "./chunk-JCMTJHXH.js"; import { require_react } from "./chunk-6VO5C3OI.js"; @@ -19,209 +68,22 @@ import { } from "./chunk-WOOG5QLI.js"; // ../../node_modules/@radix-ui/react-accessible-icon/dist/index.mjs -var dist_exports3 = {}; -__export(dist_exports3, { +var dist_exports6 = {}; +__export(dist_exports6, { AccessibleIcon: () => AccessibleIcon, - Root: () => Root22 -}); -var React5 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-visually-hidden/dist/index.mjs -var dist_exports2 = {}; -__export(dist_exports2, { - Root: () => Root2, - VISUALLY_HIDDEN_STYLES: () => VISUALLY_HIDDEN_STYLES, - VisuallyHidden: () => VisuallyHidden -}); -var React4 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-primitive/dist/index.mjs -var React3 = __toESM(require_react(), 1); -var ReactDOM = __toESM(require_react_dom(), 1); - -// ../../node_modules/@radix-ui/react-slot/dist/index.mjs -var dist_exports = {}; -__export(dist_exports, { - Root: () => Slot, - Slot: () => Slot, - Slottable: () => Slottable, - createSlot: () => createSlot, - createSlottable: () => createSlottable + Root: () => Root23 }); var React2 = __toESM(require_react(), 1); -// ../../node_modules/@radix-ui/react-compose-refs/dist/index.mjs -var React = __toESM(require_react(), 1); -function setRef(ref, value) { - if (typeof ref === "function") { - return ref(value); - } else if (ref !== null && ref !== void 0) { - ref.current = value; - } -} -function composeRefs(...refs) { - return (node) => { - let hasCleanup = false; - const cleanups = refs.map((ref) => { - const cleanup = setRef(ref, node); - if (!hasCleanup && typeof cleanup == "function") { - hasCleanup = true; - } - return cleanup; - }); - if (hasCleanup) { - return () => { - for (let i = 0; i < cleanups.length; i++) { - const cleanup = cleanups[i]; - if (typeof cleanup == "function") { - cleanup(); - } else { - setRef(refs[i], null); - } - } - }; - } - }; -} -function useComposedRefs(...refs) { - return React.useCallback(composeRefs(...refs), refs); -} - -// ../../node_modules/@radix-ui/react-slot/dist/index.mjs -var import_jsx_runtime = __toESM(require_jsx_runtime(), 1); -function createSlot(ownerName) { - const SlotClone = createSlotClone(ownerName); - const Slot22 = React2.forwardRef((props, forwardedRef) => { - const { children, ...slotProps } = props; - const childrenArray = React2.Children.toArray(children); - const slottable = childrenArray.find(isSlottable); - if (slottable) { - const newElement = slottable.props.children; - const newChildren = childrenArray.map((child) => { - if (child === slottable) { - if (React2.Children.count(newElement) > 1) return React2.Children.only(null); - return React2.isValidElement(newElement) ? newElement.props.children : null; - } else { - return child; - } - }); - return (0, import_jsx_runtime.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children: React2.isValidElement(newElement) ? React2.cloneElement(newElement, void 0, newChildren) : null }); - } - return (0, import_jsx_runtime.jsx)(SlotClone, { ...slotProps, ref: forwardedRef, children }); - }); - Slot22.displayName = `${ownerName}.Slot`; - return Slot22; -} -var Slot = createSlot("Slot"); -function createSlotClone(ownerName) { - const SlotClone = React2.forwardRef((props, forwardedRef) => { - const { children, ...slotProps } = props; - if (React2.isValidElement(children)) { - const childrenRef = getElementRef(children); - const props2 = mergeProps(slotProps, children.props); - if (children.type !== React2.Fragment) { - props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef; - } - return React2.cloneElement(children, props2); - } - return React2.Children.count(children) > 1 ? React2.Children.only(null) : null; - }); - SlotClone.displayName = `${ownerName}.SlotClone`; - return SlotClone; -} -var SLOTTABLE_IDENTIFIER = Symbol("radix.slottable"); -function createSlottable(ownerName) { - const Slottable22 = ({ children }) => { - return (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children }); - }; - Slottable22.displayName = `${ownerName}.Slottable`; - Slottable22.__radixId = SLOTTABLE_IDENTIFIER; - return Slottable22; -} -var Slottable = createSlottable("Slottable"); -function isSlottable(child) { - return React2.isValidElement(child) && typeof child.type === "function" && "__radixId" in child.type && child.type.__radixId === SLOTTABLE_IDENTIFIER; -} -function mergeProps(slotProps, childProps) { - const overrideProps = { ...childProps }; - for (const propName in childProps) { - const slotPropValue = slotProps[propName]; - const childPropValue = childProps[propName]; - const isHandler = /^on[A-Z]/.test(propName); - if (isHandler) { - if (slotPropValue && childPropValue) { - overrideProps[propName] = (...args) => { - const result = childPropValue(...args); - slotPropValue(...args); - return result; - }; - } else if (slotPropValue) { - overrideProps[propName] = slotPropValue; - } - } else if (propName === "style") { - overrideProps[propName] = { ...slotPropValue, ...childPropValue }; - } else if (propName === "className") { - overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" "); - } - } - return { ...slotProps, ...overrideProps }; -} -function getElementRef(element) { - var _a2, _b; - let getter = (_a2 = Object.getOwnPropertyDescriptor(element.props, "ref")) == null ? void 0 : _a2.get; - let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning; - if (mayWarn) { - return element.ref; - } - getter = (_b = Object.getOwnPropertyDescriptor(element, "ref")) == null ? void 0 : _b.get; - mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning; - if (mayWarn) { - return element.props.ref; - } - return element.props.ref || element.ref; -} - -// ../../node_modules/@radix-ui/react-primitive/dist/index.mjs -var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1); -var NODES = [ - "a", - "button", - "div", - "form", - "h2", - "h3", - "img", - "input", - "label", - "li", - "nav", - "ol", - "p", - "select", - "span", - "svg", - "ul" -]; -var Primitive = NODES.reduce((primitive, node) => { - const Slot6 = createSlot(`Primitive.${node}`); - const Node2 = React3.forwardRef((props, forwardedRef) => { - const { asChild, ...primitiveProps } = props; - const Comp = asChild ? Slot6 : node; - if (typeof window !== "undefined") { - window[Symbol.for("radix-ui")] = true; - } - return (0, import_jsx_runtime2.jsx)(Comp, { ...primitiveProps, ref: forwardedRef }); - }); - Node2.displayName = `Primitive.${node}`; - return { ...primitive, [node]: Node2 }; -}, {}); -function dispatchDiscreteCustomEvent(target, event) { - if (target) ReactDOM.flushSync(() => target.dispatchEvent(event)); -} -var Root = Primitive; - // ../../node_modules/@radix-ui/react-visually-hidden/dist/index.mjs -var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1); +var dist_exports5 = {}; +__export(dist_exports5, { + Root: () => Root4, + VISUALLY_HIDDEN_STYLES: () => VISUALLY_HIDDEN_STYLES, + VisuallyHidden: () => VisuallyHidden +}); +var React = __toESM(require_react(), 1); +var import_jsx_runtime = __toESM(require_jsx_runtime(), 1); var VISUALLY_HIDDEN_STYLES = Object.freeze({ // See: https://github.com/twbs/bootstrap/blob/main/scss/mixins/_visually-hidden.scss position: "absolute", @@ -236,9 +98,9 @@ var VISUALLY_HIDDEN_STYLES = Object.freeze({ wordWrap: "normal" }); var NAME = "VisuallyHidden"; -var VisuallyHidden = React4.forwardRef( +var VisuallyHidden = React.forwardRef( (props, forwardedRef) => { - return (0, import_jsx_runtime3.jsx)( + return (0, import_jsx_runtime.jsx)( Primitive.span, { ...props, @@ -249,127 +111,48 @@ var VisuallyHidden = React4.forwardRef( } ); VisuallyHidden.displayName = NAME; -var Root2 = VisuallyHidden; +var Root4 = VisuallyHidden; // ../../node_modules/@radix-ui/react-accessible-icon/dist/index.mjs -var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1); +var import_jsx_runtime2 = __toESM(require_jsx_runtime(), 1); var NAME2 = "AccessibleIcon"; var AccessibleIcon = ({ children, label }) => { - const child = React5.Children.only(children); - return (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [ - React5.cloneElement(child, { + const child = React2.Children.only(children); + return (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [ + React2.cloneElement(child, { // accessibility "aria-hidden": "true", focusable: "false" // See: https://allyjs.io/tutorials/focusing-in-svg.html#making-svg-elements-focusable }), - (0, import_jsx_runtime4.jsx)(Root2, { children: label }) + (0, import_jsx_runtime2.jsx)(Root4, { children: label }) ] }); }; AccessibleIcon.displayName = NAME2; -var Root22 = AccessibleIcon; +var Root23 = AccessibleIcon; // ../../node_modules/@radix-ui/react-accordion/dist/index.mjs -var dist_exports6 = {}; -__export(dist_exports6, { +var dist_exports9 = {}; +__export(dist_exports9, { Accordion: () => Accordion, AccordionContent: () => AccordionContent, AccordionHeader: () => AccordionHeader, AccordionItem: () => AccordionItem, AccordionTrigger: () => AccordionTrigger, - Content: () => Content2, + Content: () => Content22, Header: () => Header, Item: () => Item, - Root: () => Root23, - Trigger: () => Trigger2, + Root: () => Root24, + Trigger: () => Trigger22, createAccordionScope: () => createAccordionScope }); var import_react3 = __toESM(require_react(), 1); -// ../../node_modules/@radix-ui/react-context/dist/index.mjs -var React6 = __toESM(require_react(), 1); -var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1); -function createContext2(rootComponentName, defaultContext) { - const Context = React6.createContext(defaultContext); - const Provider4 = (props) => { - const { children, ...context } = props; - const value = React6.useMemo(() => context, Object.values(context)); - return (0, import_jsx_runtime5.jsx)(Context.Provider, { value, children }); - }; - Provider4.displayName = rootComponentName + "Provider"; - function useContext22(consumerName) { - const context = React6.useContext(Context); - if (context) return context; - if (defaultContext !== void 0) return defaultContext; - throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``); - } - return [Provider4, useContext22]; -} -function createContextScope(scopeName, createContextScopeDeps = []) { - let defaultContexts = []; - function createContext32(rootComponentName, defaultContext) { - const BaseContext = React6.createContext(defaultContext); - const index2 = defaultContexts.length; - defaultContexts = [...defaultContexts, defaultContext]; - const Provider4 = (props) => { - var _a2; - const { scope, children, ...context } = props; - const Context = ((_a2 = scope == null ? void 0 : scope[scopeName]) == null ? void 0 : _a2[index2]) || BaseContext; - const value = React6.useMemo(() => context, Object.values(context)); - return (0, import_jsx_runtime5.jsx)(Context.Provider, { value, children }); - }; - Provider4.displayName = rootComponentName + "Provider"; - function useContext22(consumerName, scope) { - var _a2; - const Context = ((_a2 = scope == null ? void 0 : scope[scopeName]) == null ? void 0 : _a2[index2]) || BaseContext; - const context = React6.useContext(Context); - if (context) return context; - if (defaultContext !== void 0) return defaultContext; - throw new Error(`\`${consumerName}\` must be used within \`${rootComponentName}\``); - } - return [Provider4, useContext22]; - } - const createScope = () => { - const scopeContexts = defaultContexts.map((defaultContext) => { - return React6.createContext(defaultContext); - }); - return function useScope(scope) { - const contexts = (scope == null ? void 0 : scope[scopeName]) || scopeContexts; - return React6.useMemo( - () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }), - [scope, contexts] - ); - }; - }; - createScope.scopeName = scopeName; - return [createContext32, composeContextScopes(createScope, ...createContextScopeDeps)]; -} -function composeContextScopes(...scopes) { - const baseScope = scopes[0]; - if (scopes.length === 1) return baseScope; - const createScope = () => { - const scopeHooks = scopes.map((createScope2) => ({ - useScope: createScope2(), - scopeName: createScope2.scopeName - })); - return function useComposedScopes(overrideScopes) { - const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => { - const scopeProps = useScope(overrideScopes); - const currentScope = scopeProps[`__scope${scopeName}`]; - return { ...nextScopes2, ...currentScope }; - }, {}); - return React6.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]); - }; - }; - createScope.scopeName = baseScope.scopeName; - return createScope; -} - // ../../node_modules/@radix-ui/react-collection/dist/index.mjs var import_react = __toESM(require_react(), 1); -var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1); +var import_jsx_runtime3 = __toESM(require_jsx_runtime(), 1); var import_react2 = __toESM(require_react(), 1); -var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1); +var import_jsx_runtime4 = __toESM(require_jsx_runtime(), 1); function createCollection(name) { const PROVIDER_NAME3 = name + "CollectionProvider"; const [createCollectionContext, createCollectionScope10] = createContextScope(PROVIDER_NAME3); @@ -381,7 +164,7 @@ function createCollection(name) { const { scope, children } = props; const ref = import_react.default.useRef(null); const itemMap = import_react.default.useRef(/* @__PURE__ */ new Map()).current; - return (0, import_jsx_runtime6.jsx)(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children }); + return (0, import_jsx_runtime3.jsx)(CollectionProviderImpl, { scope, itemMap, collectionRef: ref, children }); }; CollectionProvider.displayName = PROVIDER_NAME3; const COLLECTION_SLOT_NAME = name + "CollectionSlot"; @@ -391,7 +174,7 @@ function createCollection(name) { const { scope, children } = props; const context = useCollectionContext(COLLECTION_SLOT_NAME, scope); const composedRefs = useComposedRefs(forwardedRef, context.collectionRef); - return (0, import_jsx_runtime6.jsx)(CollectionSlotImpl, { ref: composedRefs, children }); + return (0, import_jsx_runtime3.jsx)(CollectionSlotImpl, { ref: composedRefs, children }); } ); CollectionSlot.displayName = COLLECTION_SLOT_NAME; @@ -408,7 +191,7 @@ function createCollection(name) { context.itemMap.set(ref, { ref, ...itemData }); return () => void context.itemMap.delete(ref); }); - return (0, import_jsx_runtime6.jsx)(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children }); + return (0, import_jsx_runtime3.jsx)(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children }); } ); CollectionItemSlot.displayName = ITEM_SLOT_NAME; @@ -452,24 +235,24 @@ var OrderedDict = (_a = class extends Map { super.set(key, value); return this; } - insert(index2, key, value) { + insert(index, key, value) { const has = this.has(key); const length = __privateGet(this, _keys).length; - const relativeIndex = toSafeInteger(index2); + const relativeIndex = toSafeInteger(index); let actualIndex = relativeIndex >= 0 ? relativeIndex : length + relativeIndex; const safeIndex = actualIndex < 0 || actualIndex >= length ? -1 : actualIndex; if (safeIndex === this.size || has && safeIndex === this.size - 1 || safeIndex === -1) { this.set(key, value); return this; } - const size4 = this.size + (has ? 0 : 1); + const size = this.size + (has ? 0 : 1); if (relativeIndex < 0) { actualIndex++; } const keys = [...__privateGet(this, _keys)]; let nextValue; let shouldSkip = false; - for (let i = actualIndex; i < size4; i++) { + for (let i = actualIndex; i < size; i++) { if (actualIndex === i) { let nextKey = keys[i]; if (keys[i] === key) { @@ -493,45 +276,45 @@ var OrderedDict = (_a = class extends Map { } return this; } - with(index2, key, value) { + with(index, key, value) { const copy = new _a(this); - copy.insert(index2, key, value); + copy.insert(index, key, value); return copy; } before(key) { - const index2 = __privateGet(this, _keys).indexOf(key) - 1; - if (index2 < 0) { + const index = __privateGet(this, _keys).indexOf(key) - 1; + if (index < 0) { return void 0; } - return this.entryAt(index2); + return this.entryAt(index); } /** * Sets a new key-value pair at the position before the given key. */ setBefore(key, newKey, value) { - const index2 = __privateGet(this, _keys).indexOf(key); - if (index2 === -1) { + const index = __privateGet(this, _keys).indexOf(key); + if (index === -1) { return this; } - return this.insert(index2, newKey, value); + return this.insert(index, newKey, value); } after(key) { - let index2 = __privateGet(this, _keys).indexOf(key); - index2 = index2 === -1 || index2 === this.size - 1 ? -1 : index2 + 1; - if (index2 === -1) { + let index = __privateGet(this, _keys).indexOf(key); + index = index === -1 || index === this.size - 1 ? -1 : index + 1; + if (index === -1) { return void 0; } - return this.entryAt(index2); + return this.entryAt(index); } /** * Sets a new key-value pair at the position after the given key. */ setAfter(key, newKey, value) { - const index2 = __privateGet(this, _keys).indexOf(key); - if (index2 === -1) { + const index = __privateGet(this, _keys).indexOf(key); + if (index === -1) { return this; } - return this.insert(index2 + 1, newKey, value); + return this.insert(index + 1, newKey, value); } first() { return this.entryAt(0); @@ -550,21 +333,21 @@ var OrderedDict = (_a = class extends Map { } return deleted; } - deleteAt(index2) { - const key = this.keyAt(index2); + deleteAt(index) { + const key = this.keyAt(index); if (key !== void 0) { return this.delete(key); } return false; } - at(index2) { - const key = at(__privateGet(this, _keys), index2); + at(index) { + const key = at(__privateGet(this, _keys), index); if (key !== void 0) { return this.get(key); } } - entryAt(index2) { - const key = at(__privateGet(this, _keys), index2); + entryAt(index) { + const key = at(__privateGet(this, _keys), index); if (key !== void 0) { return [key, this.get(key)]; } @@ -572,92 +355,92 @@ var OrderedDict = (_a = class extends Map { indexOf(key) { return __privateGet(this, _keys).indexOf(key); } - keyAt(index2) { - return at(__privateGet(this, _keys), index2); + keyAt(index) { + return at(__privateGet(this, _keys), index); } - from(key, offset4) { - const index2 = this.indexOf(key); - if (index2 === -1) { + from(key, offset) { + const index = this.indexOf(key); + if (index === -1) { return void 0; } - let dest = index2 + offset4; + let dest = index + offset; if (dest < 0) dest = 0; if (dest >= this.size) dest = this.size - 1; return this.at(dest); } - keyFrom(key, offset4) { - const index2 = this.indexOf(key); - if (index2 === -1) { + keyFrom(key, offset) { + const index = this.indexOf(key); + if (index === -1) { return void 0; } - let dest = index2 + offset4; + let dest = index + offset; if (dest < 0) dest = 0; if (dest >= this.size) dest = this.size - 1; return this.keyAt(dest); } find(predicate, thisArg) { - let index2 = 0; + let index = 0; for (const entry of this) { - if (Reflect.apply(predicate, thisArg, [entry, index2, this])) { + if (Reflect.apply(predicate, thisArg, [entry, index, this])) { return entry; } - index2++; + index++; } return void 0; } findIndex(predicate, thisArg) { - let index2 = 0; + let index = 0; for (const entry of this) { - if (Reflect.apply(predicate, thisArg, [entry, index2, this])) { - return index2; + if (Reflect.apply(predicate, thisArg, [entry, index, this])) { + return index; } - index2++; + index++; } return -1; } filter(predicate, thisArg) { const entries = []; - let index2 = 0; + let index = 0; for (const entry of this) { - if (Reflect.apply(predicate, thisArg, [entry, index2, this])) { + if (Reflect.apply(predicate, thisArg, [entry, index, this])) { entries.push(entry); } - index2++; + index++; } return new _a(entries); } map(callbackfn, thisArg) { const entries = []; - let index2 = 0; + let index = 0; for (const entry of this) { - entries.push([entry[0], Reflect.apply(callbackfn, thisArg, [entry, index2, this])]); - index2++; + entries.push([entry[0], Reflect.apply(callbackfn, thisArg, [entry, index, this])]); + index++; } return new _a(entries); } reduce(...args) { const [callbackfn, initialValue] = args; - let index2 = 0; + let index = 0; let accumulator = initialValue ?? this.at(0); for (const entry of this) { - if (index2 === 0 && args.length === 1) { + if (index === 0 && args.length === 1) { accumulator = entry; } else { - accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]); + accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index, this]); } - index2++; + index++; } return accumulator; } reduceRight(...args) { const [callbackfn, initialValue] = args; let accumulator = initialValue ?? this.at(-1); - for (let index2 = this.size - 1; index2 >= 0; index2--) { - const entry = this.at(index2); - if (index2 === this.size - 1 && args.length === 1) { + for (let index = this.size - 1; index >= 0; index--) { + const entry = this.at(index); + if (index === this.size - 1 && args.length === 1) { accumulator = entry; } else { - accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index2, this]); + accumulator = Reflect.apply(callbackfn, this, [accumulator, entry, index, this]); } } return accumulator; @@ -668,8 +451,8 @@ var OrderedDict = (_a = class extends Map { } toReversed() { const reversed = new _a(); - for (let index2 = this.size - 1; index2 >= 0; index2--) { - const key = this.keyAt(index2); + for (let index = this.size - 1; index >= 0; index--) { + const key = this.keyAt(index); const element = this.get(key); reversed.set(key, element); } @@ -692,44 +475,44 @@ var OrderedDict = (_a = class extends Map { if (end !== void 0 && end > 0) { stop = end - 1; } - for (let index2 = start; index2 <= stop; index2++) { - const key = this.keyAt(index2); + for (let index = start; index <= stop; index++) { + const key = this.keyAt(index); const element = this.get(key); result.set(key, element); } return result; } every(predicate, thisArg) { - let index2 = 0; + let index = 0; for (const entry of this) { - if (!Reflect.apply(predicate, thisArg, [entry, index2, this])) { + if (!Reflect.apply(predicate, thisArg, [entry, index, this])) { return false; } - index2++; + index++; } return true; } some(predicate, thisArg) { - let index2 = 0; + let index = 0; for (const entry of this) { - if (Reflect.apply(predicate, thisArg, [entry, index2, this])) { + if (Reflect.apply(predicate, thisArg, [entry, index, this])) { return true; } - index2++; + index++; } return false; } }, _keys = new WeakMap(), _a); -function at(array, index2) { +function at(array, index) { if ("at" in Array.prototype) { - return Array.prototype.at.call(array, index2); + return Array.prototype.at.call(array, index); } - const actualIndex = toSafeIndex(array, index2); + const actualIndex = toSafeIndex(array, index); return actualIndex === -1 ? void 0 : array[actualIndex]; } -function toSafeIndex(array, index2) { +function toSafeIndex(array, index) { const length = array.length; - const relativeIndex = toSafeInteger(index2); + const relativeIndex = toSafeInteger(index); const actualIndex = relativeIndex >= 0 ? relativeIndex : length + relativeIndex; return actualIndex < 0 || actualIndex >= length ? -1 : actualIndex; } @@ -750,12 +533,12 @@ function createCollection2(name) { } ); const CollectionProvider = ({ state, ...props }) => { - return state ? (0, import_jsx_runtime7.jsx)(CollectionProviderImpl, { ...props, state }) : (0, import_jsx_runtime7.jsx)(CollectionInit, { ...props }); + return state ? (0, import_jsx_runtime4.jsx)(CollectionProviderImpl, { ...props, state }) : (0, import_jsx_runtime4.jsx)(CollectionInit, { ...props }); }; CollectionProvider.displayName = PROVIDER_NAME3; const CollectionInit = (props) => { const state = useInitCollection2(); - return (0, import_jsx_runtime7.jsx)(CollectionProviderImpl, { ...props, state }); + return (0, import_jsx_runtime4.jsx)(CollectionProviderImpl, { ...props, state }); }; CollectionInit.displayName = PROVIDER_NAME3 + "Init"; const CollectionProviderImpl = (props) => { @@ -778,7 +561,7 @@ function createCollection2(name) { observer.disconnect(); }; }, [collectionElement]); - return (0, import_jsx_runtime7.jsx)( + return (0, import_jsx_runtime4.jsx)( CollectionContextProvider, { scope, @@ -799,7 +582,7 @@ function createCollection2(name) { const { scope, children } = props; const context = useCollectionContext(COLLECTION_SLOT_NAME, scope); const composedRefs = useComposedRefs(forwardedRef, context.collectionRef); - return (0, import_jsx_runtime7.jsx)(CollectionSlotImpl, { ref: composedRefs, children }); + return (0, import_jsx_runtime4.jsx)(CollectionSlotImpl, { ref: composedRefs, children }); } ); CollectionSlot.displayName = COLLECTION_SLOT_NAME; @@ -841,7 +624,7 @@ function createCollection2(name) { }); }; }, [element, memoizedItemData, setItemMap]); - return (0, import_jsx_runtime7.jsx)(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children }); + return (0, import_jsx_runtime4.jsx)(CollectionItemSlotImpl, { ...{ [ITEM_DATA_ATTR]: "" }, ref: composedRefs, children }); } ); CollectionItemSlot.displayName = ITEM_SLOT_NAME; @@ -893,281 +676,23 @@ function getChildListObserver(callback) { return observer; } -// ../../node_modules/@radix-ui/primitive/dist/index.mjs -var canUseDOM = !!(typeof window !== "undefined" && window.document && window.document.createElement); -function composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) { - return function handleEvent(event) { - originalEventHandler == null ? void 0 : originalEventHandler(event); - if (checkForDefaultPrevented === false || !event.defaultPrevented) { - return ourEventHandler == null ? void 0 : ourEventHandler(event); - } - }; -} - -// ../../node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs -var React10 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs -var React8 = __toESM(require_react(), 1); -var useLayoutEffect2 = (globalThis == null ? void 0 : globalThis.document) ? React8.useLayoutEffect : () => { -}; - -// ../../node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs -var React23 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-use-effect-event/dist/index.mjs -var React9 = __toESM(require_react(), 1); -var useReactEffectEvent = React9[" useEffectEvent ".trim().toString()]; -var useReactInsertionEffect = React9[" useInsertionEffect ".trim().toString()]; -function useEffectEvent(callback) { - if (typeof useReactEffectEvent === "function") { - return useReactEffectEvent(callback); - } - const ref = React9.useRef(() => { - throw new Error("Cannot call an event handler while rendering."); - }); - if (typeof useReactInsertionEffect === "function") { - useReactInsertionEffect(() => { - ref.current = callback; - }); - } else { - useLayoutEffect2(() => { - ref.current = callback; - }); - } - return React9.useMemo(() => (...args) => { - var _a2; - return (_a2 = ref.current) == null ? void 0 : _a2.call(ref, ...args); - }, []); -} - -// ../../node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs -var useInsertionEffect = React10[" useInsertionEffect ".trim().toString()] || useLayoutEffect2; -function useControllableState({ - prop, - defaultProp, - onChange = () => { - }, - caller -}) { - const [uncontrolledProp, setUncontrolledProp, onChangeRef] = useUncontrolledState({ - defaultProp, - onChange - }); - const isControlled = prop !== void 0; - const value = isControlled ? prop : uncontrolledProp; - if (true) { - const isControlledRef = React10.useRef(prop !== void 0); - React10.useEffect(() => { - const wasControlled = isControlledRef.current; - if (wasControlled !== isControlled) { - const from = wasControlled ? "controlled" : "uncontrolled"; - const to = isControlled ? "controlled" : "uncontrolled"; - console.warn( - `${caller} is changing from ${from} to ${to}. Components should not switch from controlled to uncontrolled (or vice versa). Decide between using a controlled or uncontrolled value for the lifetime of the component.` - ); - } - isControlledRef.current = isControlled; - }, [isControlled, caller]); - } - const setValue = React10.useCallback( - (nextValue) => { - var _a2; - if (isControlled) { - const value2 = isFunction(nextValue) ? nextValue(prop) : nextValue; - if (value2 !== prop) { - (_a2 = onChangeRef.current) == null ? void 0 : _a2.call(onChangeRef, value2); - } - } else { - setUncontrolledProp(nextValue); - } - }, - [isControlled, prop, setUncontrolledProp, onChangeRef] - ); - return [value, setValue]; -} -function useUncontrolledState({ - defaultProp, - onChange -}) { - const [value, setValue] = React10.useState(defaultProp); - const prevValueRef = React10.useRef(value); - const onChangeRef = React10.useRef(onChange); - useInsertionEffect(() => { - onChangeRef.current = onChange; - }, [onChange]); - React10.useEffect(() => { - var _a2; - if (prevValueRef.current !== value) { - (_a2 = onChangeRef.current) == null ? void 0 : _a2.call(onChangeRef, value); - prevValueRef.current = value; - } - }, [value, prevValueRef]); - return [value, setValue, onChangeRef]; -} -function isFunction(value) { - return typeof value === "function"; -} -var SYNC_STATE = Symbol("RADIX:SYNC_STATE"); - // ../../node_modules/@radix-ui/react-collapsible/dist/index.mjs -var dist_exports4 = {}; -__export(dist_exports4, { +var dist_exports7 = {}; +__export(dist_exports7, { Collapsible: () => Collapsible, CollapsibleContent: () => CollapsibleContent, CollapsibleTrigger: () => CollapsibleTrigger, - Content: () => Content, - Root: () => Root3, - Trigger: () => Trigger, + Content: () => Content3, + Root: () => Root5, + Trigger: () => Trigger2, createCollapsibleScope: () => createCollapsibleScope }); -var React13 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-presence/dist/index.mjs -var React24 = __toESM(require_react(), 1); -var React11 = __toESM(require_react(), 1); -function useStateMachine(initialState, machine) { - return React11.useReducer((state, event) => { - const nextState = machine[state][event]; - return nextState ?? state; - }, initialState); -} -var Presence = (props) => { - const { present, children } = props; - const presence = usePresence(present); - const child = typeof children === "function" ? children({ present: presence.isPresent }) : React24.Children.only(children); - const ref = useComposedRefs(presence.ref, getElementRef2(child)); - const forceMount = typeof children === "function"; - return forceMount || presence.isPresent ? React24.cloneElement(child, { ref }) : null; -}; -Presence.displayName = "Presence"; -function usePresence(present) { - const [node, setNode] = React24.useState(); - const stylesRef = React24.useRef(null); - const prevPresentRef = React24.useRef(present); - const prevAnimationNameRef = React24.useRef("none"); - const initialState = present ? "mounted" : "unmounted"; - const [state, send] = useStateMachine(initialState, { - mounted: { - UNMOUNT: "unmounted", - ANIMATION_OUT: "unmountSuspended" - }, - unmountSuspended: { - MOUNT: "mounted", - ANIMATION_END: "unmounted" - }, - unmounted: { - MOUNT: "mounted" - } - }); - React24.useEffect(() => { - const currentAnimationName = getAnimationName(stylesRef.current); - prevAnimationNameRef.current = state === "mounted" ? currentAnimationName : "none"; - }, [state]); - useLayoutEffect2(() => { - const styles = stylesRef.current; - const wasPresent = prevPresentRef.current; - const hasPresentChanged = wasPresent !== present; - if (hasPresentChanged) { - const prevAnimationName = prevAnimationNameRef.current; - const currentAnimationName = getAnimationName(styles); - if (present) { - send("MOUNT"); - } else if (currentAnimationName === "none" || (styles == null ? void 0 : styles.display) === "none") { - send("UNMOUNT"); - } else { - const isAnimating = prevAnimationName !== currentAnimationName; - if (wasPresent && isAnimating) { - send("ANIMATION_OUT"); - } else { - send("UNMOUNT"); - } - } - prevPresentRef.current = present; - } - }, [present, send]); - useLayoutEffect2(() => { - if (node) { - let timeoutId; - const ownerWindow = node.ownerDocument.defaultView ?? window; - const handleAnimationEnd = (event) => { - const currentAnimationName = getAnimationName(stylesRef.current); - const isCurrentAnimation = currentAnimationName.includes(CSS.escape(event.animationName)); - if (event.target === node && isCurrentAnimation) { - send("ANIMATION_END"); - if (!prevPresentRef.current) { - const currentFillMode = node.style.animationFillMode; - node.style.animationFillMode = "forwards"; - timeoutId = ownerWindow.setTimeout(() => { - if (node.style.animationFillMode === "forwards") { - node.style.animationFillMode = currentFillMode; - } - }); - } - } - }; - const handleAnimationStart = (event) => { - if (event.target === node) { - prevAnimationNameRef.current = getAnimationName(stylesRef.current); - } - }; - node.addEventListener("animationstart", handleAnimationStart); - node.addEventListener("animationcancel", handleAnimationEnd); - node.addEventListener("animationend", handleAnimationEnd); - return () => { - ownerWindow.clearTimeout(timeoutId); - node.removeEventListener("animationstart", handleAnimationStart); - node.removeEventListener("animationcancel", handleAnimationEnd); - node.removeEventListener("animationend", handleAnimationEnd); - }; - } else { - send("ANIMATION_END"); - } - }, [node, send]); - return { - isPresent: ["mounted", "unmountSuspended"].includes(state), - ref: React24.useCallback((node2) => { - stylesRef.current = node2 ? getComputedStyle(node2) : null; - setNode(node2); - }, []) - }; -} -function getAnimationName(styles) { - return (styles == null ? void 0 : styles.animationName) || "none"; -} -function getElementRef2(element) { - var _a2, _b; - let getter = (_a2 = Object.getOwnPropertyDescriptor(element.props, "ref")) == null ? void 0 : _a2.get; - let mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning; - if (mayWarn) { - return element.ref; - } - getter = (_b = Object.getOwnPropertyDescriptor(element, "ref")) == null ? void 0 : _b.get; - mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning; - if (mayWarn) { - return element.props.ref; - } - return element.props.ref || element.ref; -} - -// ../../node_modules/@radix-ui/react-id/dist/index.mjs -var React12 = __toESM(require_react(), 1); -var useReactId = React12[" useId ".trim().toString()] || (() => void 0); -var count = 0; -function useId(deterministicId) { - const [id, setId] = React12.useState(useReactId()); - useLayoutEffect2(() => { - if (!deterministicId) setId((reactId) => reactId ?? String(count++)); - }, [deterministicId]); - return deterministicId || (id ? `radix-${id}` : ""); -} - -// ../../node_modules/@radix-ui/react-collapsible/dist/index.mjs -var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1); +var React4 = __toESM(require_react(), 1); +var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1); var COLLAPSIBLE_NAME = "Collapsible"; var [createCollapsibleContext, createCollapsibleScope] = createContextScope(COLLAPSIBLE_NAME); var [CollapsibleProvider, useCollapsibleContext] = createCollapsibleContext(COLLAPSIBLE_NAME); -var Collapsible = React13.forwardRef( +var Collapsible = React4.forwardRef( (props, forwardedRef) => { const { __scopeCollapsible, @@ -1183,15 +708,15 @@ var Collapsible = React13.forwardRef( onChange: onOpenChange, caller: COLLAPSIBLE_NAME }); - return (0, import_jsx_runtime8.jsx)( + return (0, import_jsx_runtime5.jsx)( CollapsibleProvider, { scope: __scopeCollapsible, disabled, contentId: useId(), open, - onOpenToggle: React13.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]), - children: (0, import_jsx_runtime8.jsx)( + onOpenToggle: React4.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]), + children: (0, import_jsx_runtime5.jsx)( Primitive.div, { "data-state": getState(open), @@ -1206,11 +731,11 @@ var Collapsible = React13.forwardRef( ); Collapsible.displayName = COLLAPSIBLE_NAME; var TRIGGER_NAME = "CollapsibleTrigger"; -var CollapsibleTrigger = React13.forwardRef( +var CollapsibleTrigger = React4.forwardRef( (props, forwardedRef) => { const { __scopeCollapsible, ...triggerProps } = props; const context = useCollapsibleContext(TRIGGER_NAME, __scopeCollapsible); - return (0, import_jsx_runtime8.jsx)( + return (0, import_jsx_runtime5.jsx)( Primitive.button, { type: "button", @@ -1228,28 +753,28 @@ var CollapsibleTrigger = React13.forwardRef( ); CollapsibleTrigger.displayName = TRIGGER_NAME; var CONTENT_NAME = "CollapsibleContent"; -var CollapsibleContent = React13.forwardRef( +var CollapsibleContent = React4.forwardRef( (props, forwardedRef) => { const { forceMount, ...contentProps } = props; const context = useCollapsibleContext(CONTENT_NAME, props.__scopeCollapsible); - return (0, import_jsx_runtime8.jsx)(Presence, { present: forceMount || context.open, children: ({ present }) => (0, import_jsx_runtime8.jsx)(CollapsibleContentImpl, { ...contentProps, ref: forwardedRef, present }) }); + return (0, import_jsx_runtime5.jsx)(Presence, { present: forceMount || context.open, children: ({ present }) => (0, import_jsx_runtime5.jsx)(CollapsibleContentImpl, { ...contentProps, ref: forwardedRef, present }) }); } ); CollapsibleContent.displayName = CONTENT_NAME; -var CollapsibleContentImpl = React13.forwardRef((props, forwardedRef) => { +var CollapsibleContentImpl = React4.forwardRef((props, forwardedRef) => { const { __scopeCollapsible, present, children, ...contentProps } = props; const context = useCollapsibleContext(CONTENT_NAME, __scopeCollapsible); - const [isPresent, setIsPresent] = React13.useState(present); - const ref = React13.useRef(null); + const [isPresent, setIsPresent] = React4.useState(present); + const ref = React4.useRef(null); const composedRefs = useComposedRefs(forwardedRef, ref); - const heightRef = React13.useRef(0); + const heightRef = React4.useRef(0); const height = heightRef.current; - const widthRef = React13.useRef(0); + const widthRef = React4.useRef(0); const width = widthRef.current; const isOpen = context.open || isPresent; - const isMountAnimationPreventedRef = React13.useRef(isOpen); - const originalStylesRef = React13.useRef(void 0); - React13.useEffect(() => { + const isMountAnimationPreventedRef = React4.useRef(isOpen); + const originalStylesRef = React4.useRef(void 0); + React4.useEffect(() => { const rAF = requestAnimationFrame(() => isMountAnimationPreventedRef.current = false); return () => cancelAnimationFrame(rAF); }, []); @@ -1272,7 +797,7 @@ var CollapsibleContentImpl = React13.forwardRef((props, forwardedRef) => { setIsPresent(present); } }, [context.open, present]); - return (0, import_jsx_runtime8.jsx)( + return (0, import_jsx_runtime5.jsx)( Primitive.div, { "data-state": getState(context.open), @@ -1293,32 +818,32 @@ var CollapsibleContentImpl = React13.forwardRef((props, forwardedRef) => { function getState(open) { return open ? "open" : "closed"; } -var Root3 = Collapsible; -var Trigger = CollapsibleTrigger; -var Content = CollapsibleContent; +var Root5 = Collapsible; +var Trigger2 = CollapsibleTrigger; +var Content3 = CollapsibleContent; // ../../node_modules/@radix-ui/react-direction/dist/index.mjs -var dist_exports5 = {}; -__export(dist_exports5, { +var dist_exports8 = {}; +__export(dist_exports8, { DirectionProvider: () => DirectionProvider, Provider: () => Provider, useDirection: () => useDirection }); -var React14 = __toESM(require_react(), 1); -var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1); -var DirectionContext = React14.createContext(void 0); +var React5 = __toESM(require_react(), 1); +var import_jsx_runtime6 = __toESM(require_jsx_runtime(), 1); +var DirectionContext = React5.createContext(void 0); var DirectionProvider = (props) => { const { dir, children } = props; - return (0, import_jsx_runtime9.jsx)(DirectionContext.Provider, { value: dir, children }); + return (0, import_jsx_runtime6.jsx)(DirectionContext.Provider, { value: dir, children }); }; function useDirection(localDir) { - const globalDir = React14.useContext(DirectionContext); + const globalDir = React5.useContext(DirectionContext); return localDir || globalDir || "ltr"; } var Provider = DirectionProvider; // ../../node_modules/@radix-ui/react-accordion/dist/index.mjs -var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1); +var import_jsx_runtime7 = __toESM(require_jsx_runtime(), 1); var ACCORDION_NAME = "Accordion"; var ACCORDION_KEYS = ["Home", "End", "ArrowDown", "ArrowUp", "ArrowLeft", "ArrowRight"]; var [Collection, useCollection, createCollectionScope] = createCollection(ACCORDION_NAME); @@ -1332,7 +857,7 @@ var Accordion = import_react3.default.forwardRef( const { type, ...accordionProps } = props; const singleProps = accordionProps; const multipleProps = accordionProps; - return (0, import_jsx_runtime10.jsx)(Collection.Provider, { scope: props.__scopeAccordion, children: type === "multiple" ? (0, import_jsx_runtime10.jsx)(AccordionImplMultiple, { ...multipleProps, ref: forwardedRef }) : (0, import_jsx_runtime10.jsx)(AccordionImplSingle, { ...singleProps, ref: forwardedRef }) }); + return (0, import_jsx_runtime7.jsx)(Collection.Provider, { scope: props.__scopeAccordion, children: type === "multiple" ? (0, import_jsx_runtime7.jsx)(AccordionImplMultiple, { ...multipleProps, ref: forwardedRef }) : (0, import_jsx_runtime7.jsx)(AccordionImplSingle, { ...singleProps, ref: forwardedRef }) }); } ); Accordion.displayName = ACCORDION_NAME; @@ -1357,14 +882,14 @@ var AccordionImplSingle = import_react3.default.forwardRef( onChange: onValueChange, caller: ACCORDION_NAME }); - return (0, import_jsx_runtime10.jsx)( + return (0, import_jsx_runtime7.jsx)( AccordionValueProvider, { scope: props.__scopeAccordion, value: import_react3.default.useMemo(() => value ? [value] : [], [value]), onItemOpen: setValue, onItemClose: import_react3.default.useCallback(() => collapsible && setValue(""), [collapsible, setValue]), - children: (0, import_jsx_runtime10.jsx)(AccordionCollapsibleProvider, { scope: props.__scopeAccordion, collapsible, children: (0, import_jsx_runtime10.jsx)(AccordionImpl, { ...accordionSingleProps, ref: forwardedRef }) }) + children: (0, import_jsx_runtime7.jsx)(AccordionCollapsibleProvider, { scope: props.__scopeAccordion, collapsible, children: (0, import_jsx_runtime7.jsx)(AccordionImpl, { ...accordionSingleProps, ref: forwardedRef }) }) } ); } @@ -1391,14 +916,14 @@ var AccordionImplMultiple = import_react3.default.forwardRef((props, forwardedRe (itemValue) => setValue((prevValue = []) => prevValue.filter((value2) => value2 !== itemValue)), [setValue] ); - return (0, import_jsx_runtime10.jsx)( + return (0, import_jsx_runtime7.jsx)( AccordionValueProvider, { scope: props.__scopeAccordion, value, onItemOpen: handleItemOpen, onItemClose: handleItemClose, - children: (0, import_jsx_runtime10.jsx)(AccordionCollapsibleProvider, { scope: props.__scopeAccordion, collapsible: true, children: (0, import_jsx_runtime10.jsx)(AccordionImpl, { ...accordionMultipleProps, ref: forwardedRef }) }) + children: (0, import_jsx_runtime7.jsx)(AccordionCollapsibleProvider, { scope: props.__scopeAccordion, collapsible: true, children: (0, import_jsx_runtime7.jsx)(AccordionImpl, { ...accordionMultipleProps, ref: forwardedRef }) }) } ); }); @@ -1477,14 +1002,14 @@ var AccordionImpl = import_react3.default.forwardRef( const clampedIndex = nextIndex % triggerCount; (_a2 = triggerCollection[clampedIndex].ref.current) == null ? void 0 : _a2.focus(); }); - return (0, import_jsx_runtime10.jsx)( + return (0, import_jsx_runtime7.jsx)( AccordionImplProvider, { scope: __scopeAccordion, disabled, direction: dir, orientation, - children: (0, import_jsx_runtime10.jsx)(Collection.Slot, { scope: __scopeAccordion, children: (0, import_jsx_runtime10.jsx)( + children: (0, import_jsx_runtime7.jsx)(Collection.Slot, { scope: __scopeAccordion, children: (0, import_jsx_runtime7.jsx)( Primitive.div, { ...accordionProps, @@ -1508,15 +1033,15 @@ var AccordionItem = import_react3.default.forwardRef( const triggerId = useId(); const open = value && valueContext.value.includes(value) || false; const disabled = accordionContext.disabled || props.disabled; - return (0, import_jsx_runtime10.jsx)( + return (0, import_jsx_runtime7.jsx)( AccordionItemProvider, { scope: __scopeAccordion, open, disabled, triggerId, - children: (0, import_jsx_runtime10.jsx)( - Root3, + children: (0, import_jsx_runtime7.jsx)( + Root5, { "data-orientation": accordionContext.orientation, "data-state": getState2(open), @@ -1545,7 +1070,7 @@ var AccordionHeader = import_react3.default.forwardRef( const { __scopeAccordion, ...headerProps } = props; const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion); const itemContext = useAccordionItemContext(HEADER_NAME, __scopeAccordion); - return (0, import_jsx_runtime10.jsx)( + return (0, import_jsx_runtime7.jsx)( Primitive.h3, { "data-orientation": accordionContext.orientation, @@ -1566,8 +1091,8 @@ var AccordionTrigger = import_react3.default.forwardRef( const itemContext = useAccordionItemContext(TRIGGER_NAME2, __scopeAccordion); const collapsibleContext = useAccordionCollapsibleContext(TRIGGER_NAME2, __scopeAccordion); const collapsibleScope = useCollapsibleScope(__scopeAccordion); - return (0, import_jsx_runtime10.jsx)(Collection.ItemSlot, { scope: __scopeAccordion, children: (0, import_jsx_runtime10.jsx)( - Trigger, + return (0, import_jsx_runtime7.jsx)(Collection.ItemSlot, { scope: __scopeAccordion, children: (0, import_jsx_runtime7.jsx)( + Trigger2, { "aria-disabled": itemContext.open && !collapsibleContext.collapsible || void 0, "data-orientation": accordionContext.orientation, @@ -1587,8 +1112,8 @@ var AccordionContent = import_react3.default.forwardRef( const accordionContext = useAccordionContext(ACCORDION_NAME, __scopeAccordion); const itemContext = useAccordionItemContext(CONTENT_NAME2, __scopeAccordion); const collapsibleScope = useCollapsibleScope(__scopeAccordion); - return (0, import_jsx_runtime10.jsx)( - Content, + return (0, import_jsx_runtime7.jsx)( + Content3, { role: "region", "aria-labelledby": itemContext.triggerId, @@ -1609,15 +1134,15 @@ AccordionContent.displayName = CONTENT_NAME2; function getState2(open) { return open ? "open" : "closed"; } -var Root23 = Accordion; +var Root24 = Accordion; var Item = AccordionItem; var Header = AccordionHeader; -var Trigger2 = AccordionTrigger; -var Content2 = AccordionContent; +var Trigger22 = AccordionTrigger; +var Content22 = AccordionContent; // ../../node_modules/@radix-ui/react-alert-dialog/dist/index.mjs -var dist_exports9 = {}; -__export(dist_exports9, { +var dist_exports10 = {}; +__export(dist_exports10, { Action: () => Action, AlertDialog: () => AlertDialog, AlertDialogAction: () => AlertDialogAction, @@ -1629,1695 +1154,17 @@ __export(dist_exports9, { AlertDialogTitle: () => AlertDialogTitle, AlertDialogTrigger: () => AlertDialogTrigger, Cancel: () => Cancel, - Content: () => Content22, + Content: () => Content23, Description: () => Description2, Overlay: () => Overlay2, Portal: () => Portal22, - Root: () => Root24, + Root: () => Root25, Title: () => Title2, - Trigger: () => Trigger22, + Trigger: () => Trigger23, createAlertDialogScope: () => createAlertDialogScope }); -var React35 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-dialog/dist/index.mjs -var dist_exports8 = {}; -__export(dist_exports8, { - Close: () => Close, - Content: () => Content3, - Description: () => Description, - Dialog: () => Dialog, - DialogClose: () => DialogClose, - DialogContent: () => DialogContent, - DialogDescription: () => DialogDescription, - DialogOverlay: () => DialogOverlay, - DialogPortal: () => DialogPortal, - DialogTitle: () => DialogTitle, - DialogTrigger: () => DialogTrigger, - Overlay: () => Overlay, - Portal: () => Portal2, - Root: () => Root6, - Title: () => Title, - Trigger: () => Trigger3, - WarningProvider: () => WarningProvider, - createDialogScope: () => createDialogScope -}); -var React34 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs -var React18 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs -var React16 = __toESM(require_react(), 1); -function useCallbackRef(callback) { - const callbackRef = React16.useRef(callback); - React16.useEffect(() => { - callbackRef.current = callback; - }); - return React16.useMemo(() => (...args) => { - var _a2; - return (_a2 = callbackRef.current) == null ? void 0 : _a2.call(callbackRef, ...args); - }, []); -} - -// ../../node_modules/@radix-ui/react-use-escape-keydown/dist/index.mjs -var React17 = __toESM(require_react(), 1); -function useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis == null ? void 0 : globalThis.document) { - const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp); - React17.useEffect(() => { - const handleKeyDown = (event) => { - if (event.key === "Escape") { - onEscapeKeyDown(event); - } - }; - ownerDocument.addEventListener("keydown", handleKeyDown, { capture: true }); - return () => ownerDocument.removeEventListener("keydown", handleKeyDown, { capture: true }); - }, [onEscapeKeyDown, ownerDocument]); -} - -// ../../node_modules/@radix-ui/react-dismissable-layer/dist/index.mjs -var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1); -var DISMISSABLE_LAYER_NAME = "DismissableLayer"; -var CONTEXT_UPDATE = "dismissableLayer.update"; -var POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside"; -var FOCUS_OUTSIDE = "dismissableLayer.focusOutside"; -var originalBodyPointerEvents; -var DismissableLayerContext = React18.createContext({ - layers: /* @__PURE__ */ new Set(), - layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(), - branches: /* @__PURE__ */ new Set() -}); -var DismissableLayer = React18.forwardRef( - (props, forwardedRef) => { - const { - disableOutsidePointerEvents = false, - onEscapeKeyDown, - onPointerDownOutside, - onFocusOutside, - onInteractOutside, - onDismiss, - ...layerProps - } = props; - const context = React18.useContext(DismissableLayerContext); - const [node, setNode] = React18.useState(null); - const ownerDocument = (node == null ? void 0 : node.ownerDocument) ?? (globalThis == null ? void 0 : globalThis.document); - const [, force] = React18.useState({}); - const composedRefs = useComposedRefs(forwardedRef, (node2) => setNode(node2)); - const layers = Array.from(context.layers); - const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1); - const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled); - const index2 = node ? layers.indexOf(node) : -1; - const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0; - const isPointerEventsEnabled = index2 >= highestLayerWithOutsidePointerEventsDisabledIndex; - const pointerDownOutside = usePointerDownOutside((event) => { - const target = event.target; - const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target)); - if (!isPointerEventsEnabled || isPointerDownOnBranch) return; - onPointerDownOutside == null ? void 0 : onPointerDownOutside(event); - onInteractOutside == null ? void 0 : onInteractOutside(event); - if (!event.defaultPrevented) onDismiss == null ? void 0 : onDismiss(); - }, ownerDocument); - const focusOutside = useFocusOutside((event) => { - const target = event.target; - const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target)); - if (isFocusInBranch) return; - onFocusOutside == null ? void 0 : onFocusOutside(event); - onInteractOutside == null ? void 0 : onInteractOutside(event); - if (!event.defaultPrevented) onDismiss == null ? void 0 : onDismiss(); - }, ownerDocument); - useEscapeKeydown((event) => { - const isHighestLayer = index2 === context.layers.size - 1; - if (!isHighestLayer) return; - onEscapeKeyDown == null ? void 0 : onEscapeKeyDown(event); - if (!event.defaultPrevented && onDismiss) { - event.preventDefault(); - onDismiss(); - } - }, ownerDocument); - React18.useEffect(() => { - if (!node) return; - if (disableOutsidePointerEvents) { - if (context.layersWithOutsidePointerEventsDisabled.size === 0) { - originalBodyPointerEvents = ownerDocument.body.style.pointerEvents; - ownerDocument.body.style.pointerEvents = "none"; - } - context.layersWithOutsidePointerEventsDisabled.add(node); - } - context.layers.add(node); - dispatchUpdate(); - return () => { - if (disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) { - ownerDocument.body.style.pointerEvents = originalBodyPointerEvents; - } - }; - }, [node, ownerDocument, disableOutsidePointerEvents, context]); - React18.useEffect(() => { - return () => { - if (!node) return; - context.layers.delete(node); - context.layersWithOutsidePointerEventsDisabled.delete(node); - dispatchUpdate(); - }; - }, [node, context]); - React18.useEffect(() => { - const handleUpdate = () => force({}); - document.addEventListener(CONTEXT_UPDATE, handleUpdate); - return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate); - }, []); - return (0, import_jsx_runtime11.jsx)( - Primitive.div, - { - ...layerProps, - ref: composedRefs, - style: { - pointerEvents: isBodyPointerEventsDisabled ? isPointerEventsEnabled ? "auto" : "none" : void 0, - ...props.style - }, - onFocusCapture: composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture), - onBlurCapture: composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture), - onPointerDownCapture: composeEventHandlers( - props.onPointerDownCapture, - pointerDownOutside.onPointerDownCapture - ) - } - ); - } -); -DismissableLayer.displayName = DISMISSABLE_LAYER_NAME; -var BRANCH_NAME = "DismissableLayerBranch"; -var DismissableLayerBranch = React18.forwardRef((props, forwardedRef) => { - const context = React18.useContext(DismissableLayerContext); - const ref = React18.useRef(null); - const composedRefs = useComposedRefs(forwardedRef, ref); - React18.useEffect(() => { - const node = ref.current; - if (node) { - context.branches.add(node); - return () => { - context.branches.delete(node); - }; - } - }, [context.branches]); - return (0, import_jsx_runtime11.jsx)(Primitive.div, { ...props, ref: composedRefs }); -}); -DismissableLayerBranch.displayName = BRANCH_NAME; -function usePointerDownOutside(onPointerDownOutside, ownerDocument = globalThis == null ? void 0 : globalThis.document) { - const handlePointerDownOutside = useCallbackRef(onPointerDownOutside); - const isPointerInsideReactTreeRef = React18.useRef(false); - const handleClickRef = React18.useRef(() => { - }); - React18.useEffect(() => { - const handlePointerDown = (event) => { - if (event.target && !isPointerInsideReactTreeRef.current) { - let handleAndDispatchPointerDownOutsideEvent2 = function() { - handleAndDispatchCustomEvent( - POINTER_DOWN_OUTSIDE, - handlePointerDownOutside, - eventDetail, - { discrete: true } - ); - }; - var handleAndDispatchPointerDownOutsideEvent = handleAndDispatchPointerDownOutsideEvent2; - const eventDetail = { originalEvent: event }; - if (event.pointerType === "touch") { - ownerDocument.removeEventListener("click", handleClickRef.current); - handleClickRef.current = handleAndDispatchPointerDownOutsideEvent2; - ownerDocument.addEventListener("click", handleClickRef.current, { once: true }); - } else { - handleAndDispatchPointerDownOutsideEvent2(); - } - } else { - ownerDocument.removeEventListener("click", handleClickRef.current); - } - isPointerInsideReactTreeRef.current = false; - }; - const timerId = window.setTimeout(() => { - ownerDocument.addEventListener("pointerdown", handlePointerDown); - }, 0); - return () => { - window.clearTimeout(timerId); - ownerDocument.removeEventListener("pointerdown", handlePointerDown); - ownerDocument.removeEventListener("click", handleClickRef.current); - }; - }, [ownerDocument, handlePointerDownOutside]); - return { - // ensures we check React component tree (not just DOM tree) - onPointerDownCapture: () => isPointerInsideReactTreeRef.current = true - }; -} -function useFocusOutside(onFocusOutside, ownerDocument = globalThis == null ? void 0 : globalThis.document) { - const handleFocusOutside = useCallbackRef(onFocusOutside); - const isFocusInsideReactTreeRef = React18.useRef(false); - React18.useEffect(() => { - const handleFocus = (event) => { - if (event.target && !isFocusInsideReactTreeRef.current) { - const eventDetail = { originalEvent: event }; - handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, { - discrete: false - }); - } - }; - ownerDocument.addEventListener("focusin", handleFocus); - return () => ownerDocument.removeEventListener("focusin", handleFocus); - }, [ownerDocument, handleFocusOutside]); - return { - onFocusCapture: () => isFocusInsideReactTreeRef.current = true, - onBlurCapture: () => isFocusInsideReactTreeRef.current = false - }; -} -function dispatchUpdate() { - const event = new CustomEvent(CONTEXT_UPDATE); - document.dispatchEvent(event); -} -function handleAndDispatchCustomEvent(name, handler, detail, { discrete }) { - const target = detail.originalEvent.target; - const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail }); - if (handler) target.addEventListener(name, handler, { once: true }); - if (discrete) { - dispatchDiscreteCustomEvent(target, event); - } else { - target.dispatchEvent(event); - } -} -var Root4 = DismissableLayer; -var Branch = DismissableLayerBranch; - -// ../../node_modules/@radix-ui/react-focus-scope/dist/index.mjs -var React19 = __toESM(require_react(), 1); -var import_jsx_runtime12 = __toESM(require_jsx_runtime(), 1); -var AUTOFOCUS_ON_MOUNT = "focusScope.autoFocusOnMount"; -var AUTOFOCUS_ON_UNMOUNT = "focusScope.autoFocusOnUnmount"; -var EVENT_OPTIONS = { bubbles: false, cancelable: true }; -var FOCUS_SCOPE_NAME = "FocusScope"; -var FocusScope = React19.forwardRef((props, forwardedRef) => { - const { - loop = false, - trapped = false, - onMountAutoFocus: onMountAutoFocusProp, - onUnmountAutoFocus: onUnmountAutoFocusProp, - ...scopeProps - } = props; - const [container, setContainer] = React19.useState(null); - const onMountAutoFocus = useCallbackRef(onMountAutoFocusProp); - const onUnmountAutoFocus = useCallbackRef(onUnmountAutoFocusProp); - const lastFocusedElementRef = React19.useRef(null); - const composedRefs = useComposedRefs(forwardedRef, (node) => setContainer(node)); - const focusScope = React19.useRef({ - paused: false, - pause() { - this.paused = true; - }, - resume() { - this.paused = false; - } - }).current; - React19.useEffect(() => { - if (trapped) { - let handleFocusIn2 = function(event) { - if (focusScope.paused || !container) return; - const target = event.target; - if (container.contains(target)) { - lastFocusedElementRef.current = target; - } else { - focus(lastFocusedElementRef.current, { select: true }); - } - }, handleFocusOut2 = function(event) { - if (focusScope.paused || !container) return; - const relatedTarget = event.relatedTarget; - if (relatedTarget === null) return; - if (!container.contains(relatedTarget)) { - focus(lastFocusedElementRef.current, { select: true }); - } - }, handleMutations2 = function(mutations) { - const focusedElement = document.activeElement; - if (focusedElement !== document.body) return; - for (const mutation of mutations) { - if (mutation.removedNodes.length > 0) focus(container); - } - }; - var handleFocusIn = handleFocusIn2, handleFocusOut = handleFocusOut2, handleMutations = handleMutations2; - document.addEventListener("focusin", handleFocusIn2); - document.addEventListener("focusout", handleFocusOut2); - const mutationObserver = new MutationObserver(handleMutations2); - if (container) mutationObserver.observe(container, { childList: true, subtree: true }); - return () => { - document.removeEventListener("focusin", handleFocusIn2); - document.removeEventListener("focusout", handleFocusOut2); - mutationObserver.disconnect(); - }; - } - }, [trapped, container, focusScope.paused]); - React19.useEffect(() => { - if (container) { - focusScopesStack.add(focusScope); - const previouslyFocusedElement = document.activeElement; - const hasFocusedCandidate = container.contains(previouslyFocusedElement); - if (!hasFocusedCandidate) { - const mountEvent = new CustomEvent(AUTOFOCUS_ON_MOUNT, EVENT_OPTIONS); - container.addEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus); - container.dispatchEvent(mountEvent); - if (!mountEvent.defaultPrevented) { - focusFirst(removeLinks(getTabbableCandidates(container)), { select: true }); - if (document.activeElement === previouslyFocusedElement) { - focus(container); - } - } - } - return () => { - container.removeEventListener(AUTOFOCUS_ON_MOUNT, onMountAutoFocus); - setTimeout(() => { - const unmountEvent = new CustomEvent(AUTOFOCUS_ON_UNMOUNT, EVENT_OPTIONS); - container.addEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus); - container.dispatchEvent(unmountEvent); - if (!unmountEvent.defaultPrevented) { - focus(previouslyFocusedElement ?? document.body, { select: true }); - } - container.removeEventListener(AUTOFOCUS_ON_UNMOUNT, onUnmountAutoFocus); - focusScopesStack.remove(focusScope); - }, 0); - }; - } - }, [container, onMountAutoFocus, onUnmountAutoFocus, focusScope]); - const handleKeyDown = React19.useCallback( - (event) => { - if (!loop && !trapped) return; - if (focusScope.paused) return; - const isTabKey = event.key === "Tab" && !event.altKey && !event.ctrlKey && !event.metaKey; - const focusedElement = document.activeElement; - if (isTabKey && focusedElement) { - const container2 = event.currentTarget; - const [first, last] = getTabbableEdges(container2); - const hasTabbableElementsInside = first && last; - if (!hasTabbableElementsInside) { - if (focusedElement === container2) event.preventDefault(); - } else { - if (!event.shiftKey && focusedElement === last) { - event.preventDefault(); - if (loop) focus(first, { select: true }); - } else if (event.shiftKey && focusedElement === first) { - event.preventDefault(); - if (loop) focus(last, { select: true }); - } - } - } - }, - [loop, trapped, focusScope.paused] - ); - return (0, import_jsx_runtime12.jsx)(Primitive.div, { tabIndex: -1, ...scopeProps, ref: composedRefs, onKeyDown: handleKeyDown }); -}); -FocusScope.displayName = FOCUS_SCOPE_NAME; -function focusFirst(candidates, { select = false } = {}) { - const previouslyFocusedElement = document.activeElement; - for (const candidate of candidates) { - focus(candidate, { select }); - if (document.activeElement !== previouslyFocusedElement) return; - } -} -function getTabbableEdges(container) { - const candidates = getTabbableCandidates(container); - const first = findVisible(candidates, container); - const last = findVisible(candidates.reverse(), container); - return [first, last]; -} -function getTabbableCandidates(container) { - const nodes = []; - const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, { - acceptNode: (node) => { - const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden"; - if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP; - return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP; - } - }); - while (walker.nextNode()) nodes.push(walker.currentNode); - return nodes; -} -function findVisible(elements, container) { - for (const element of elements) { - if (!isHidden(element, { upTo: container })) return element; - } -} -function isHidden(node, { upTo }) { - if (getComputedStyle(node).visibility === "hidden") return true; - while (node) { - if (upTo !== void 0 && node === upTo) return false; - if (getComputedStyle(node).display === "none") return true; - node = node.parentElement; - } - return false; -} -function isSelectableInput(element) { - return element instanceof HTMLInputElement && "select" in element; -} -function focus(element, { select = false } = {}) { - if (element && element.focus) { - const previouslyFocusedElement = document.activeElement; - element.focus({ preventScroll: true }); - if (element !== previouslyFocusedElement && isSelectableInput(element) && select) - element.select(); - } -} -var focusScopesStack = createFocusScopesStack(); -function createFocusScopesStack() { - let stack = []; - return { - add(focusScope) { - const activeFocusScope = stack[0]; - if (focusScope !== activeFocusScope) { - activeFocusScope == null ? void 0 : activeFocusScope.pause(); - } - stack = arrayRemove(stack, focusScope); - stack.unshift(focusScope); - }, - remove(focusScope) { - var _a2; - stack = arrayRemove(stack, focusScope); - (_a2 = stack[0]) == null ? void 0 : _a2.resume(); - } - }; -} -function arrayRemove(array, item) { - const updatedArray = [...array]; - const index2 = updatedArray.indexOf(item); - if (index2 !== -1) { - updatedArray.splice(index2, 1); - } - return updatedArray; -} -function removeLinks(items) { - return items.filter((item) => item.tagName !== "A"); -} - -// ../../node_modules/@radix-ui/react-portal/dist/index.mjs -var dist_exports7 = {}; -__export(dist_exports7, { - Portal: () => Portal, - Root: () => Root5 -}); -var React20 = __toESM(require_react(), 1); -var import_react_dom = __toESM(require_react_dom(), 1); -var import_jsx_runtime13 = __toESM(require_jsx_runtime(), 1); -var PORTAL_NAME = "Portal"; -var Portal = React20.forwardRef((props, forwardedRef) => { - var _a2; - const { container: containerProp, ...portalProps } = props; - const [mounted, setMounted] = React20.useState(false); - useLayoutEffect2(() => setMounted(true), []); - const container = containerProp || mounted && ((_a2 = globalThis == null ? void 0 : globalThis.document) == null ? void 0 : _a2.body); - return container ? import_react_dom.default.createPortal((0, import_jsx_runtime13.jsx)(Primitive.div, { ...portalProps, ref: forwardedRef }), container) : null; -}); -Portal.displayName = PORTAL_NAME; -var Root5 = Portal; - -// ../../node_modules/@radix-ui/react-focus-guards/dist/index.mjs -var React21 = __toESM(require_react(), 1); -var count2 = 0; -function useFocusGuards() { - React21.useEffect(() => { - const edgeGuards = document.querySelectorAll("[data-radix-focus-guard]"); - document.body.insertAdjacentElement("afterbegin", edgeGuards[0] ?? createFocusGuard()); - document.body.insertAdjacentElement("beforeend", edgeGuards[1] ?? createFocusGuard()); - count2++; - return () => { - if (count2 === 1) { - document.querySelectorAll("[data-radix-focus-guard]").forEach((node) => node.remove()); - } - count2--; - }; - }, []); -} -function createFocusGuard() { - const element = document.createElement("span"); - element.setAttribute("data-radix-focus-guard", ""); - element.tabIndex = 0; - element.style.outline = "none"; - element.style.opacity = "0"; - element.style.position = "fixed"; - element.style.pointerEvents = "none"; - return element; -} - -// ../../node_modules/tslib/tslib.es6.mjs -var __assign = function() { - __assign = Object.assign || function __assign2(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -function __rest(s, e) { - var t = {}; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) - t[p] = s[p]; - if (s != null && typeof Object.getOwnPropertySymbols === "function") - for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { - if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) - t[p[i]] = s[p[i]]; - } - return t; -} -function __spreadArray(to, from, pack) { - if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { - if (ar || !(i in from)) { - if (!ar) ar = Array.prototype.slice.call(from, 0, i); - ar[i] = from[i]; - } - } - return to.concat(ar || Array.prototype.slice.call(from)); -} - -// ../../node_modules/react-remove-scroll/dist/es2015/Combination.js -var React33 = __toESM(require_react()); - -// ../../node_modules/react-remove-scroll/dist/es2015/UI.js -var React29 = __toESM(require_react()); - -// ../../node_modules/react-remove-scroll-bar/dist/es2015/constants.js -var zeroRightClassName = "right-scroll-bar-position"; -var fullWidthClassName = "width-before-scroll-bar"; -var noScrollbarsClassName = "with-scroll-bars-hidden"; -var removedBarSizeVariable = "--removed-body-scroll-bar-size"; - -// ../../node_modules/use-callback-ref/dist/es2015/assignRef.js -function assignRef(ref, value) { - if (typeof ref === "function") { - ref(value); - } else if (ref) { - ref.current = value; - } - return ref; -} - -// ../../node_modules/use-callback-ref/dist/es2015/useRef.js -var import_react4 = __toESM(require_react()); -function useCallbackRef2(initialValue, callback) { - var ref = (0, import_react4.useState)(function() { - return { - // value - value: initialValue, - // last callback - callback, - // "memoized" public interface - facade: { - get current() { - return ref.value; - }, - set current(value) { - var last = ref.value; - if (last !== value) { - ref.value = value; - ref.callback(value, last); - } - } - } - }; - })[0]; - ref.callback = callback; - return ref.facade; -} - -// ../../node_modules/use-callback-ref/dist/es2015/useMergeRef.js -var React25 = __toESM(require_react()); -var useIsomorphicLayoutEffect = typeof window !== "undefined" ? React25.useLayoutEffect : React25.useEffect; -var currentValues = /* @__PURE__ */ new WeakMap(); -function useMergeRefs(refs, defaultValue) { - var callbackRef = useCallbackRef2(defaultValue || null, function(newValue) { - return refs.forEach(function(ref) { - return assignRef(ref, newValue); - }); - }); - useIsomorphicLayoutEffect(function() { - var oldValue = currentValues.get(callbackRef); - if (oldValue) { - var prevRefs_1 = new Set(oldValue); - var nextRefs_1 = new Set(refs); - var current_1 = callbackRef.current; - prevRefs_1.forEach(function(ref) { - if (!nextRefs_1.has(ref)) { - assignRef(ref, null); - } - }); - nextRefs_1.forEach(function(ref) { - if (!prevRefs_1.has(ref)) { - assignRef(ref, current_1); - } - }); - } - currentValues.set(callbackRef, refs); - }, [refs]); - return callbackRef; -} - -// ../../node_modules/use-sidecar/dist/es2015/hoc.js -var React26 = __toESM(require_react()); - -// ../../node_modules/use-sidecar/dist/es2015/hook.js -var import_react5 = __toESM(require_react()); - -// ../../node_modules/use-sidecar/dist/es2015/medium.js -function ItoI(a) { - return a; -} -function innerCreateMedium(defaults, middleware) { - if (middleware === void 0) { - middleware = ItoI; - } - var buffer = []; - var assigned = false; - var medium = { - read: function() { - if (assigned) { - throw new Error("Sidecar: could not `read` from an `assigned` medium. `read` could be used only with `useMedium`."); - } - if (buffer.length) { - return buffer[buffer.length - 1]; - } - return defaults; - }, - useMedium: function(data) { - var item = middleware(data, assigned); - buffer.push(item); - return function() { - buffer = buffer.filter(function(x) { - return x !== item; - }); - }; - }, - assignSyncMedium: function(cb) { - assigned = true; - while (buffer.length) { - var cbs = buffer; - buffer = []; - cbs.forEach(cb); - } - buffer = { - push: function(x) { - return cb(x); - }, - filter: function() { - return buffer; - } - }; - }, - assignMedium: function(cb) { - assigned = true; - var pendingQueue = []; - if (buffer.length) { - var cbs = buffer; - buffer = []; - cbs.forEach(cb); - pendingQueue = buffer; - } - var executeQueue = function() { - var cbs2 = pendingQueue; - pendingQueue = []; - cbs2.forEach(cb); - }; - var cycle = function() { - return Promise.resolve().then(executeQueue); - }; - cycle(); - buffer = { - push: function(x) { - pendingQueue.push(x); - cycle(); - }, - filter: function(filter) { - pendingQueue = pendingQueue.filter(filter); - return buffer; - } - }; - } - }; - return medium; -} -function createSidecarMedium(options) { - if (options === void 0) { - options = {}; - } - var medium = innerCreateMedium(null); - medium.options = __assign({ async: true, ssr: false }, options); - return medium; -} - -// ../../node_modules/use-sidecar/dist/es2015/renderProp.js -var React27 = __toESM(require_react()); -var import_react6 = __toESM(require_react()); - -// ../../node_modules/use-sidecar/dist/es2015/exports.js -var React28 = __toESM(require_react()); -var SideCar = function(_a2) { - var sideCar = _a2.sideCar, rest = __rest(_a2, ["sideCar"]); - if (!sideCar) { - throw new Error("Sidecar: please provide `sideCar` property to import the right car"); - } - var Target = sideCar.read(); - if (!Target) { - throw new Error("Sidecar medium not found"); - } - return React28.createElement(Target, __assign({}, rest)); -}; -SideCar.isSideCarExport = true; -function exportSidecar(medium, exported) { - medium.useMedium(exported); - return SideCar; -} - -// ../../node_modules/react-remove-scroll/dist/es2015/medium.js -var effectCar = createSidecarMedium(); - -// ../../node_modules/react-remove-scroll/dist/es2015/UI.js -var nothing = function() { - return; -}; -var RemoveScroll = React29.forwardRef(function(props, parentRef) { - var ref = React29.useRef(null); - var _a2 = React29.useState({ - onScrollCapture: nothing, - onWheelCapture: nothing, - onTouchMoveCapture: nothing - }), callbacks = _a2[0], setCallbacks = _a2[1]; - var forwardProps = props.forwardProps, children = props.children, className = props.className, removeScrollBar = props.removeScrollBar, enabled = props.enabled, shards = props.shards, sideCar = props.sideCar, noRelative = props.noRelative, noIsolation = props.noIsolation, inert = props.inert, allowPinchZoom = props.allowPinchZoom, _b = props.as, Container = _b === void 0 ? "div" : _b, gapMode = props.gapMode, rest = __rest(props, ["forwardProps", "children", "className", "removeScrollBar", "enabled", "shards", "sideCar", "noRelative", "noIsolation", "inert", "allowPinchZoom", "as", "gapMode"]); - var SideCar2 = sideCar; - var containerRef = useMergeRefs([ref, parentRef]); - var containerProps = __assign(__assign({}, rest), callbacks); - return React29.createElement( - React29.Fragment, - null, - enabled && React29.createElement(SideCar2, { sideCar: effectCar, removeScrollBar, shards, noRelative, noIsolation, inert, setCallbacks, allowPinchZoom: !!allowPinchZoom, lockRef: ref, gapMode }), - forwardProps ? React29.cloneElement(React29.Children.only(children), __assign(__assign({}, containerProps), { ref: containerRef })) : React29.createElement(Container, __assign({}, containerProps, { className, ref: containerRef }), children) - ); -}); -RemoveScroll.defaultProps = { - enabled: true, - removeScrollBar: true, - inert: false -}; -RemoveScroll.classNames = { - fullWidth: fullWidthClassName, - zeroRight: zeroRightClassName -}; - -// ../../node_modules/react-remove-scroll/dist/es2015/SideEffect.js -var React32 = __toESM(require_react()); - -// ../../node_modules/react-remove-scroll-bar/dist/es2015/component.js -var React31 = __toESM(require_react()); - -// ../../node_modules/react-style-singleton/dist/es2015/hook.js -var React30 = __toESM(require_react()); - -// ../../node_modules/get-nonce/dist/es2015/index.js -var currentNonce; -var getNonce = function() { - if (currentNonce) { - return currentNonce; - } - if (typeof __webpack_nonce__ !== "undefined") { - return __webpack_nonce__; - } - return void 0; -}; - -// ../../node_modules/react-style-singleton/dist/es2015/singleton.js -function makeStyleTag() { - if (!document) - return null; - var tag = document.createElement("style"); - tag.type = "text/css"; - var nonce = getNonce(); - if (nonce) { - tag.setAttribute("nonce", nonce); - } - return tag; -} -function injectStyles(tag, css) { - if (tag.styleSheet) { - tag.styleSheet.cssText = css; - } else { - tag.appendChild(document.createTextNode(css)); - } -} -function insertStyleTag(tag) { - var head = document.head || document.getElementsByTagName("head")[0]; - head.appendChild(tag); -} -var stylesheetSingleton = function() { - var counter = 0; - var stylesheet = null; - return { - add: function(style) { - if (counter == 0) { - if (stylesheet = makeStyleTag()) { - injectStyles(stylesheet, style); - insertStyleTag(stylesheet); - } - } - counter++; - }, - remove: function() { - counter--; - if (!counter && stylesheet) { - stylesheet.parentNode && stylesheet.parentNode.removeChild(stylesheet); - stylesheet = null; - } - } - }; -}; - -// ../../node_modules/react-style-singleton/dist/es2015/hook.js -var styleHookSingleton = function() { - var sheet = stylesheetSingleton(); - return function(styles, isDynamic) { - React30.useEffect(function() { - sheet.add(styles); - return function() { - sheet.remove(); - }; - }, [styles && isDynamic]); - }; -}; - -// ../../node_modules/react-style-singleton/dist/es2015/component.js -var styleSingleton = function() { - var useStyle = styleHookSingleton(); - var Sheet = function(_a2) { - var styles = _a2.styles, dynamic = _a2.dynamic; - useStyle(styles, dynamic); - return null; - }; - return Sheet; -}; - -// ../../node_modules/react-remove-scroll-bar/dist/es2015/utils.js -var zeroGap = { - left: 0, - top: 0, - right: 0, - gap: 0 -}; -var parse = function(x) { - return parseInt(x || "", 10) || 0; -}; -var getOffset = function(gapMode) { - var cs = window.getComputedStyle(document.body); - var left = cs[gapMode === "padding" ? "paddingLeft" : "marginLeft"]; - var top = cs[gapMode === "padding" ? "paddingTop" : "marginTop"]; - var right = cs[gapMode === "padding" ? "paddingRight" : "marginRight"]; - return [parse(left), parse(top), parse(right)]; -}; -var getGapWidth = function(gapMode) { - if (gapMode === void 0) { - gapMode = "margin"; - } - if (typeof window === "undefined") { - return zeroGap; - } - var offsets = getOffset(gapMode); - var documentWidth = document.documentElement.clientWidth; - var windowWidth = window.innerWidth; - return { - left: offsets[0], - top: offsets[1], - right: offsets[2], - gap: Math.max(0, windowWidth - documentWidth + offsets[2] - offsets[0]) - }; -}; - -// ../../node_modules/react-remove-scroll-bar/dist/es2015/component.js -var Style = styleSingleton(); -var lockAttribute = "data-scroll-locked"; -var getStyles = function(_a2, allowRelative, gapMode, important) { - var left = _a2.left, top = _a2.top, right = _a2.right, gap = _a2.gap; - if (gapMode === void 0) { - gapMode = "margin"; - } - return "\n .".concat(noScrollbarsClassName, " {\n overflow: hidden ").concat(important, ";\n padding-right: ").concat(gap, "px ").concat(important, ";\n }\n body[").concat(lockAttribute, "] {\n overflow: hidden ").concat(important, ";\n overscroll-behavior: contain;\n ").concat([ - allowRelative && "position: relative ".concat(important, ";"), - gapMode === "margin" && "\n padding-left: ".concat(left, "px;\n padding-top: ").concat(top, "px;\n padding-right: ").concat(right, "px;\n margin-left:0;\n margin-top:0;\n margin-right: ").concat(gap, "px ").concat(important, ";\n "), - gapMode === "padding" && "padding-right: ".concat(gap, "px ").concat(important, ";") - ].filter(Boolean).join(""), "\n }\n \n .").concat(zeroRightClassName, " {\n right: ").concat(gap, "px ").concat(important, ";\n }\n \n .").concat(fullWidthClassName, " {\n margin-right: ").concat(gap, "px ").concat(important, ";\n }\n \n .").concat(zeroRightClassName, " .").concat(zeroRightClassName, " {\n right: 0 ").concat(important, ";\n }\n \n .").concat(fullWidthClassName, " .").concat(fullWidthClassName, " {\n margin-right: 0 ").concat(important, ";\n }\n \n body[").concat(lockAttribute, "] {\n ").concat(removedBarSizeVariable, ": ").concat(gap, "px;\n }\n"); -}; -var getCurrentUseCounter = function() { - var counter = parseInt(document.body.getAttribute(lockAttribute) || "0", 10); - return isFinite(counter) ? counter : 0; -}; -var useLockAttribute = function() { - React31.useEffect(function() { - document.body.setAttribute(lockAttribute, (getCurrentUseCounter() + 1).toString()); - return function() { - var newCounter = getCurrentUseCounter() - 1; - if (newCounter <= 0) { - document.body.removeAttribute(lockAttribute); - } else { - document.body.setAttribute(lockAttribute, newCounter.toString()); - } - }; - }, []); -}; -var RemoveScrollBar = function(_a2) { - var noRelative = _a2.noRelative, noImportant = _a2.noImportant, _b = _a2.gapMode, gapMode = _b === void 0 ? "margin" : _b; - useLockAttribute(); - var gap = React31.useMemo(function() { - return getGapWidth(gapMode); - }, [gapMode]); - return React31.createElement(Style, { styles: getStyles(gap, !noRelative, gapMode, !noImportant ? "!important" : "") }); -}; - -// ../../node_modules/react-remove-scroll/dist/es2015/aggresiveCapture.js -var passiveSupported = false; -if (typeof window !== "undefined") { - try { - options = Object.defineProperty({}, "passive", { - get: function() { - passiveSupported = true; - return true; - } - }); - window.addEventListener("test", options, options); - window.removeEventListener("test", options, options); - } catch (err) { - passiveSupported = false; - } -} -var options; -var nonPassive = passiveSupported ? { passive: false } : false; - -// ../../node_modules/react-remove-scroll/dist/es2015/handleScroll.js -var alwaysContainsScroll = function(node) { - return node.tagName === "TEXTAREA"; -}; -var elementCanBeScrolled = function(node, overflow) { - if (!(node instanceof Element)) { - return false; - } - var styles = window.getComputedStyle(node); - return ( - // not-not-scrollable - styles[overflow] !== "hidden" && // contains scroll inside self - !(styles.overflowY === styles.overflowX && !alwaysContainsScroll(node) && styles[overflow] === "visible") - ); -}; -var elementCouldBeVScrolled = function(node) { - return elementCanBeScrolled(node, "overflowY"); -}; -var elementCouldBeHScrolled = function(node) { - return elementCanBeScrolled(node, "overflowX"); -}; -var locationCouldBeScrolled = function(axis, node) { - var ownerDocument = node.ownerDocument; - var current = node; - do { - if (typeof ShadowRoot !== "undefined" && current instanceof ShadowRoot) { - current = current.host; - } - var isScrollable = elementCouldBeScrolled(axis, current); - if (isScrollable) { - var _a2 = getScrollVariables(axis, current), scrollHeight = _a2[1], clientHeight = _a2[2]; - if (scrollHeight > clientHeight) { - return true; - } - } - current = current.parentNode; - } while (current && current !== ownerDocument.body); - return false; -}; -var getVScrollVariables = function(_a2) { - var scrollTop = _a2.scrollTop, scrollHeight = _a2.scrollHeight, clientHeight = _a2.clientHeight; - return [ - scrollTop, - scrollHeight, - clientHeight - ]; -}; -var getHScrollVariables = function(_a2) { - var scrollLeft = _a2.scrollLeft, scrollWidth = _a2.scrollWidth, clientWidth = _a2.clientWidth; - return [ - scrollLeft, - scrollWidth, - clientWidth - ]; -}; -var elementCouldBeScrolled = function(axis, node) { - return axis === "v" ? elementCouldBeVScrolled(node) : elementCouldBeHScrolled(node); -}; -var getScrollVariables = function(axis, node) { - return axis === "v" ? getVScrollVariables(node) : getHScrollVariables(node); -}; -var getDirectionFactor = function(axis, direction) { - return axis === "h" && direction === "rtl" ? -1 : 1; -}; -var handleScroll = function(axis, endTarget, event, sourceDelta, noOverscroll) { - var directionFactor = getDirectionFactor(axis, window.getComputedStyle(endTarget).direction); - var delta = directionFactor * sourceDelta; - var target = event.target; - var targetInLock = endTarget.contains(target); - var shouldCancelScroll = false; - var isDeltaPositive = delta > 0; - var availableScroll = 0; - var availableScrollTop = 0; - do { - if (!target) { - break; - } - var _a2 = getScrollVariables(axis, target), position = _a2[0], scroll_1 = _a2[1], capacity = _a2[2]; - var elementScroll = scroll_1 - capacity - directionFactor * position; - if (position || elementScroll) { - if (elementCouldBeScrolled(axis, target)) { - availableScroll += elementScroll; - availableScrollTop += position; - } - } - var parent_1 = target.parentNode; - target = parent_1 && parent_1.nodeType === Node.DOCUMENT_FRAGMENT_NODE ? parent_1.host : parent_1; - } while ( - // portaled content - !targetInLock && target !== document.body || // self content - targetInLock && (endTarget.contains(target) || endTarget === target) - ); - if (isDeltaPositive && (noOverscroll && Math.abs(availableScroll) < 1 || !noOverscroll && delta > availableScroll)) { - shouldCancelScroll = true; - } else if (!isDeltaPositive && (noOverscroll && Math.abs(availableScrollTop) < 1 || !noOverscroll && -delta > availableScrollTop)) { - shouldCancelScroll = true; - } - return shouldCancelScroll; -}; - -// ../../node_modules/react-remove-scroll/dist/es2015/SideEffect.js -var getTouchXY = function(event) { - return "changedTouches" in event ? [event.changedTouches[0].clientX, event.changedTouches[0].clientY] : [0, 0]; -}; -var getDeltaXY = function(event) { - return [event.deltaX, event.deltaY]; -}; -var extractRef = function(ref) { - return ref && "current" in ref ? ref.current : ref; -}; -var deltaCompare = function(x, y) { - return x[0] === y[0] && x[1] === y[1]; -}; -var generateStyle = function(id) { - return "\n .block-interactivity-".concat(id, " {pointer-events: none;}\n .allow-interactivity-").concat(id, " {pointer-events: all;}\n"); -}; -var idCounter = 0; -var lockStack = []; -function RemoveScrollSideCar(props) { - var shouldPreventQueue = React32.useRef([]); - var touchStartRef = React32.useRef([0, 0]); - var activeAxis = React32.useRef(); - var id = React32.useState(idCounter++)[0]; - var Style2 = React32.useState(styleSingleton)[0]; - var lastProps = React32.useRef(props); - React32.useEffect(function() { - lastProps.current = props; - }, [props]); - React32.useEffect(function() { - if (props.inert) { - document.body.classList.add("block-interactivity-".concat(id)); - var allow_1 = __spreadArray([props.lockRef.current], (props.shards || []).map(extractRef), true).filter(Boolean); - allow_1.forEach(function(el) { - return el.classList.add("allow-interactivity-".concat(id)); - }); - return function() { - document.body.classList.remove("block-interactivity-".concat(id)); - allow_1.forEach(function(el) { - return el.classList.remove("allow-interactivity-".concat(id)); - }); - }; - } - return; - }, [props.inert, props.lockRef.current, props.shards]); - var shouldCancelEvent = React32.useCallback(function(event, parent) { - if ("touches" in event && event.touches.length === 2 || event.type === "wheel" && event.ctrlKey) { - return !lastProps.current.allowPinchZoom; - } - var touch = getTouchXY(event); - var touchStart = touchStartRef.current; - var deltaX = "deltaX" in event ? event.deltaX : touchStart[0] - touch[0]; - var deltaY = "deltaY" in event ? event.deltaY : touchStart[1] - touch[1]; - var currentAxis; - var target = event.target; - var moveDirection = Math.abs(deltaX) > Math.abs(deltaY) ? "h" : "v"; - if ("touches" in event && moveDirection === "h" && target.type === "range") { - return false; - } - var selection = window.getSelection(); - var anchorNode = selection && selection.anchorNode; - var isTouchingSelection = anchorNode ? anchorNode === target || anchorNode.contains(target) : false; - if (isTouchingSelection) { - return false; - } - var canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target); - if (!canBeScrolledInMainDirection) { - return true; - } - if (canBeScrolledInMainDirection) { - currentAxis = moveDirection; - } else { - currentAxis = moveDirection === "v" ? "h" : "v"; - canBeScrolledInMainDirection = locationCouldBeScrolled(moveDirection, target); - } - if (!canBeScrolledInMainDirection) { - return false; - } - if (!activeAxis.current && "changedTouches" in event && (deltaX || deltaY)) { - activeAxis.current = currentAxis; - } - if (!currentAxis) { - return true; - } - var cancelingAxis = activeAxis.current || currentAxis; - return handleScroll(cancelingAxis, parent, event, cancelingAxis === "h" ? deltaX : deltaY, true); - }, []); - var shouldPrevent = React32.useCallback(function(_event) { - var event = _event; - if (!lockStack.length || lockStack[lockStack.length - 1] !== Style2) { - return; - } - var delta = "deltaY" in event ? getDeltaXY(event) : getTouchXY(event); - var sourceEvent = shouldPreventQueue.current.filter(function(e) { - return e.name === event.type && (e.target === event.target || event.target === e.shadowParent) && deltaCompare(e.delta, delta); - })[0]; - if (sourceEvent && sourceEvent.should) { - if (event.cancelable) { - event.preventDefault(); - } - return; - } - if (!sourceEvent) { - var shardNodes = (lastProps.current.shards || []).map(extractRef).filter(Boolean).filter(function(node) { - return node.contains(event.target); - }); - var shouldStop = shardNodes.length > 0 ? shouldCancelEvent(event, shardNodes[0]) : !lastProps.current.noIsolation; - if (shouldStop) { - if (event.cancelable) { - event.preventDefault(); - } - } - } - }, []); - var shouldCancel = React32.useCallback(function(name, delta, target, should) { - var event = { name, delta, target, should, shadowParent: getOutermostShadowParent(target) }; - shouldPreventQueue.current.push(event); - setTimeout(function() { - shouldPreventQueue.current = shouldPreventQueue.current.filter(function(e) { - return e !== event; - }); - }, 1); - }, []); - var scrollTouchStart = React32.useCallback(function(event) { - touchStartRef.current = getTouchXY(event); - activeAxis.current = void 0; - }, []); - var scrollWheel = React32.useCallback(function(event) { - shouldCancel(event.type, getDeltaXY(event), event.target, shouldCancelEvent(event, props.lockRef.current)); - }, []); - var scrollTouchMove = React32.useCallback(function(event) { - shouldCancel(event.type, getTouchXY(event), event.target, shouldCancelEvent(event, props.lockRef.current)); - }, []); - React32.useEffect(function() { - lockStack.push(Style2); - props.setCallbacks({ - onScrollCapture: scrollWheel, - onWheelCapture: scrollWheel, - onTouchMoveCapture: scrollTouchMove - }); - document.addEventListener("wheel", shouldPrevent, nonPassive); - document.addEventListener("touchmove", shouldPrevent, nonPassive); - document.addEventListener("touchstart", scrollTouchStart, nonPassive); - return function() { - lockStack = lockStack.filter(function(inst) { - return inst !== Style2; - }); - document.removeEventListener("wheel", shouldPrevent, nonPassive); - document.removeEventListener("touchmove", shouldPrevent, nonPassive); - document.removeEventListener("touchstart", scrollTouchStart, nonPassive); - }; - }, []); - var removeScrollBar = props.removeScrollBar, inert = props.inert; - return React32.createElement( - React32.Fragment, - null, - inert ? React32.createElement(Style2, { styles: generateStyle(id) }) : null, - removeScrollBar ? React32.createElement(RemoveScrollBar, { noRelative: props.noRelative, gapMode: props.gapMode }) : null - ); -} -function getOutermostShadowParent(node) { - var shadowParent = null; - while (node !== null) { - if (node instanceof ShadowRoot) { - shadowParent = node.host; - node = node.host; - } - node = node.parentNode; - } - return shadowParent; -} - -// ../../node_modules/react-remove-scroll/dist/es2015/sidecar.js -var sidecar_default = exportSidecar(effectCar, RemoveScrollSideCar); - -// ../../node_modules/react-remove-scroll/dist/es2015/Combination.js -var ReactRemoveScroll = React33.forwardRef(function(props, ref) { - return React33.createElement(RemoveScroll, __assign({}, props, { ref, sideCar: sidecar_default })); -}); -ReactRemoveScroll.classNames = RemoveScroll.classNames; -var Combination_default = ReactRemoveScroll; - -// ../../node_modules/aria-hidden/dist/es2015/index.js -var getDefaultParent = function(originalTarget) { - if (typeof document === "undefined") { - return null; - } - var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget; - return sampleTarget.ownerDocument.body; -}; -var counterMap = /* @__PURE__ */ new WeakMap(); -var uncontrolledNodes = /* @__PURE__ */ new WeakMap(); -var markerMap = {}; -var lockCount = 0; -var unwrapHost = function(node) { - return node && (node.host || unwrapHost(node.parentNode)); -}; -var correctTargets = function(parent, targets) { - return targets.map(function(target) { - if (parent.contains(target)) { - return target; - } - var correctedTarget = unwrapHost(target); - if (correctedTarget && parent.contains(correctedTarget)) { - return correctedTarget; - } - console.error("aria-hidden", target, "in not contained inside", parent, ". Doing nothing"); - return null; - }).filter(function(x) { - return Boolean(x); - }); -}; -var applyAttributeToOthers = function(originalTarget, parentNode, markerName, controlAttribute) { - var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]); - if (!markerMap[markerName]) { - markerMap[markerName] = /* @__PURE__ */ new WeakMap(); - } - var markerCounter = markerMap[markerName]; - var hiddenNodes = []; - var elementsToKeep = /* @__PURE__ */ new Set(); - var elementsToStop = new Set(targets); - var keep = function(el) { - if (!el || elementsToKeep.has(el)) { - return; - } - elementsToKeep.add(el); - keep(el.parentNode); - }; - targets.forEach(keep); - var deep = function(parent) { - if (!parent || elementsToStop.has(parent)) { - return; - } - Array.prototype.forEach.call(parent.children, function(node) { - if (elementsToKeep.has(node)) { - deep(node); - } else { - try { - var attr = node.getAttribute(controlAttribute); - var alreadyHidden = attr !== null && attr !== "false"; - var counterValue = (counterMap.get(node) || 0) + 1; - var markerValue = (markerCounter.get(node) || 0) + 1; - counterMap.set(node, counterValue); - markerCounter.set(node, markerValue); - hiddenNodes.push(node); - if (counterValue === 1 && alreadyHidden) { - uncontrolledNodes.set(node, true); - } - if (markerValue === 1) { - node.setAttribute(markerName, "true"); - } - if (!alreadyHidden) { - node.setAttribute(controlAttribute, "true"); - } - } catch (e) { - console.error("aria-hidden: cannot operate on ", node, e); - } - } - }); - }; - deep(parentNode); - elementsToKeep.clear(); - lockCount++; - return function() { - hiddenNodes.forEach(function(node) { - var counterValue = counterMap.get(node) - 1; - var markerValue = markerCounter.get(node) - 1; - counterMap.set(node, counterValue); - markerCounter.set(node, markerValue); - if (!counterValue) { - if (!uncontrolledNodes.has(node)) { - node.removeAttribute(controlAttribute); - } - uncontrolledNodes.delete(node); - } - if (!markerValue) { - node.removeAttribute(markerName); - } - }); - lockCount--; - if (!lockCount) { - counterMap = /* @__PURE__ */ new WeakMap(); - counterMap = /* @__PURE__ */ new WeakMap(); - uncontrolledNodes = /* @__PURE__ */ new WeakMap(); - markerMap = {}; - } - }; -}; -var hideOthers = function(originalTarget, parentNode, markerName) { - if (markerName === void 0) { - markerName = "data-aria-hidden"; - } - var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]); - var activeParentNode = parentNode || getDefaultParent(originalTarget); - if (!activeParentNode) { - return function() { - return null; - }; - } - targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll("[aria-live], script"))); - return applyAttributeToOthers(targets, activeParentNode, markerName, "aria-hidden"); -}; - -// ../../node_modules/@radix-ui/react-dialog/dist/index.mjs -var import_jsx_runtime14 = __toESM(require_jsx_runtime(), 1); -var DIALOG_NAME = "Dialog"; -var [createDialogContext, createDialogScope] = createContextScope(DIALOG_NAME); -var [DialogProvider, useDialogContext] = createDialogContext(DIALOG_NAME); -var Dialog = (props) => { - const { - __scopeDialog, - children, - open: openProp, - defaultOpen, - onOpenChange, - modal = true - } = props; - const triggerRef = React34.useRef(null); - const contentRef = React34.useRef(null); - const [open, setOpen] = useControllableState({ - prop: openProp, - defaultProp: defaultOpen ?? false, - onChange: onOpenChange, - caller: DIALOG_NAME - }); - return (0, import_jsx_runtime14.jsx)( - DialogProvider, - { - scope: __scopeDialog, - triggerRef, - contentRef, - contentId: useId(), - titleId: useId(), - descriptionId: useId(), - open, - onOpenChange: setOpen, - onOpenToggle: React34.useCallback(() => setOpen((prevOpen) => !prevOpen), [setOpen]), - modal, - children - } - ); -}; -Dialog.displayName = DIALOG_NAME; -var TRIGGER_NAME3 = "DialogTrigger"; -var DialogTrigger = React34.forwardRef( - (props, forwardedRef) => { - const { __scopeDialog, ...triggerProps } = props; - const context = useDialogContext(TRIGGER_NAME3, __scopeDialog); - const composedTriggerRef = useComposedRefs(forwardedRef, context.triggerRef); - return (0, import_jsx_runtime14.jsx)( - Primitive.button, - { - type: "button", - "aria-haspopup": "dialog", - "aria-expanded": context.open, - "aria-controls": context.contentId, - "data-state": getState3(context.open), - ...triggerProps, - ref: composedTriggerRef, - onClick: composeEventHandlers(props.onClick, context.onOpenToggle) - } - ); - } -); -DialogTrigger.displayName = TRIGGER_NAME3; -var PORTAL_NAME2 = "DialogPortal"; -var [PortalProvider, usePortalContext] = createDialogContext(PORTAL_NAME2, { - forceMount: void 0 -}); -var DialogPortal = (props) => { - const { __scopeDialog, forceMount, children, container } = props; - const context = useDialogContext(PORTAL_NAME2, __scopeDialog); - return (0, import_jsx_runtime14.jsx)(PortalProvider, { scope: __scopeDialog, forceMount, children: React34.Children.map(children, (child) => (0, import_jsx_runtime14.jsx)(Presence, { present: forceMount || context.open, children: (0, import_jsx_runtime14.jsx)(Portal, { asChild: true, container, children: child }) })) }); -}; -DialogPortal.displayName = PORTAL_NAME2; -var OVERLAY_NAME = "DialogOverlay"; -var DialogOverlay = React34.forwardRef( - (props, forwardedRef) => { - const portalContext = usePortalContext(OVERLAY_NAME, props.__scopeDialog); - const { forceMount = portalContext.forceMount, ...overlayProps } = props; - const context = useDialogContext(OVERLAY_NAME, props.__scopeDialog); - return context.modal ? (0, import_jsx_runtime14.jsx)(Presence, { present: forceMount || context.open, children: (0, import_jsx_runtime14.jsx)(DialogOverlayImpl, { ...overlayProps, ref: forwardedRef }) }) : null; - } -); -DialogOverlay.displayName = OVERLAY_NAME; -var Slot2 = createSlot("DialogOverlay.RemoveScroll"); -var DialogOverlayImpl = React34.forwardRef( - (props, forwardedRef) => { - const { __scopeDialog, ...overlayProps } = props; - const context = useDialogContext(OVERLAY_NAME, __scopeDialog); - return ( - // Make sure `Content` is scrollable even when it doesn't live inside `RemoveScroll` - // ie. when `Overlay` and `Content` are siblings - (0, import_jsx_runtime14.jsx)(Combination_default, { as: Slot2, allowPinchZoom: true, shards: [context.contentRef], children: (0, import_jsx_runtime14.jsx)( - Primitive.div, - { - "data-state": getState3(context.open), - ...overlayProps, - ref: forwardedRef, - style: { pointerEvents: "auto", ...overlayProps.style } - } - ) }) - ); - } -); -var CONTENT_NAME3 = "DialogContent"; -var DialogContent = React34.forwardRef( - (props, forwardedRef) => { - const portalContext = usePortalContext(CONTENT_NAME3, props.__scopeDialog); - const { forceMount = portalContext.forceMount, ...contentProps } = props; - const context = useDialogContext(CONTENT_NAME3, props.__scopeDialog); - return (0, import_jsx_runtime14.jsx)(Presence, { present: forceMount || context.open, children: context.modal ? (0, import_jsx_runtime14.jsx)(DialogContentModal, { ...contentProps, ref: forwardedRef }) : (0, import_jsx_runtime14.jsx)(DialogContentNonModal, { ...contentProps, ref: forwardedRef }) }); - } -); -DialogContent.displayName = CONTENT_NAME3; -var DialogContentModal = React34.forwardRef( - (props, forwardedRef) => { - const context = useDialogContext(CONTENT_NAME3, props.__scopeDialog); - const contentRef = React34.useRef(null); - const composedRefs = useComposedRefs(forwardedRef, context.contentRef, contentRef); - React34.useEffect(() => { - const content = contentRef.current; - if (content) return hideOthers(content); - }, []); - return (0, import_jsx_runtime14.jsx)( - DialogContentImpl, - { - ...props, - ref: composedRefs, - trapFocus: context.open, - disableOutsidePointerEvents: true, - onCloseAutoFocus: composeEventHandlers(props.onCloseAutoFocus, (event) => { - var _a2; - event.preventDefault(); - (_a2 = context.triggerRef.current) == null ? void 0 : _a2.focus(); - }), - onPointerDownOutside: composeEventHandlers(props.onPointerDownOutside, (event) => { - const originalEvent = event.detail.originalEvent; - const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true; - const isRightClick = originalEvent.button === 2 || ctrlLeftClick; - if (isRightClick) event.preventDefault(); - }), - onFocusOutside: composeEventHandlers( - props.onFocusOutside, - (event) => event.preventDefault() - ) - } - ); - } -); -var DialogContentNonModal = React34.forwardRef( - (props, forwardedRef) => { - const context = useDialogContext(CONTENT_NAME3, props.__scopeDialog); - const hasInteractedOutsideRef = React34.useRef(false); - const hasPointerDownOutsideRef = React34.useRef(false); - return (0, import_jsx_runtime14.jsx)( - DialogContentImpl, - { - ...props, - ref: forwardedRef, - trapFocus: false, - disableOutsidePointerEvents: false, - onCloseAutoFocus: (event) => { - var _a2, _b; - (_a2 = props.onCloseAutoFocus) == null ? void 0 : _a2.call(props, event); - if (!event.defaultPrevented) { - if (!hasInteractedOutsideRef.current) (_b = context.triggerRef.current) == null ? void 0 : _b.focus(); - event.preventDefault(); - } - hasInteractedOutsideRef.current = false; - hasPointerDownOutsideRef.current = false; - }, - onInteractOutside: (event) => { - var _a2, _b; - (_a2 = props.onInteractOutside) == null ? void 0 : _a2.call(props, event); - if (!event.defaultPrevented) { - hasInteractedOutsideRef.current = true; - if (event.detail.originalEvent.type === "pointerdown") { - hasPointerDownOutsideRef.current = true; - } - } - const target = event.target; - const targetIsTrigger = (_b = context.triggerRef.current) == null ? void 0 : _b.contains(target); - if (targetIsTrigger) event.preventDefault(); - if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.current) { - event.preventDefault(); - } - } - } - ); - } -); -var DialogContentImpl = React34.forwardRef( - (props, forwardedRef) => { - const { __scopeDialog, trapFocus, onOpenAutoFocus, onCloseAutoFocus, ...contentProps } = props; - const context = useDialogContext(CONTENT_NAME3, __scopeDialog); - const contentRef = React34.useRef(null); - const composedRefs = useComposedRefs(forwardedRef, contentRef); - useFocusGuards(); - return (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [ - (0, import_jsx_runtime14.jsx)( - FocusScope, - { - asChild: true, - loop: true, - trapped: trapFocus, - onMountAutoFocus: onOpenAutoFocus, - onUnmountAutoFocus: onCloseAutoFocus, - children: (0, import_jsx_runtime14.jsx)( - DismissableLayer, - { - role: "dialog", - id: context.contentId, - "aria-describedby": context.descriptionId, - "aria-labelledby": context.titleId, - "data-state": getState3(context.open), - ...contentProps, - ref: composedRefs, - onDismiss: () => context.onOpenChange(false) - } - ) - } - ), - (0, import_jsx_runtime14.jsxs)(import_jsx_runtime14.Fragment, { children: [ - (0, import_jsx_runtime14.jsx)(TitleWarning, { titleId: context.titleId }), - (0, import_jsx_runtime14.jsx)(DescriptionWarning, { contentRef, descriptionId: context.descriptionId }) - ] }) - ] }); - } -); -var TITLE_NAME = "DialogTitle"; -var DialogTitle = React34.forwardRef( - (props, forwardedRef) => { - const { __scopeDialog, ...titleProps } = props; - const context = useDialogContext(TITLE_NAME, __scopeDialog); - return (0, import_jsx_runtime14.jsx)(Primitive.h2, { id: context.titleId, ...titleProps, ref: forwardedRef }); - } -); -DialogTitle.displayName = TITLE_NAME; -var DESCRIPTION_NAME = "DialogDescription"; -var DialogDescription = React34.forwardRef( - (props, forwardedRef) => { - const { __scopeDialog, ...descriptionProps } = props; - const context = useDialogContext(DESCRIPTION_NAME, __scopeDialog); - return (0, import_jsx_runtime14.jsx)(Primitive.p, { id: context.descriptionId, ...descriptionProps, ref: forwardedRef }); - } -); -DialogDescription.displayName = DESCRIPTION_NAME; -var CLOSE_NAME = "DialogClose"; -var DialogClose = React34.forwardRef( - (props, forwardedRef) => { - const { __scopeDialog, ...closeProps } = props; - const context = useDialogContext(CLOSE_NAME, __scopeDialog); - return (0, import_jsx_runtime14.jsx)( - Primitive.button, - { - type: "button", - ...closeProps, - ref: forwardedRef, - onClick: composeEventHandlers(props.onClick, () => context.onOpenChange(false)) - } - ); - } -); -DialogClose.displayName = CLOSE_NAME; -function getState3(open) { - return open ? "open" : "closed"; -} -var TITLE_WARNING_NAME = "DialogTitleWarning"; -var [WarningProvider, useWarningContext] = createContext2(TITLE_WARNING_NAME, { - contentName: CONTENT_NAME3, - titleName: TITLE_NAME, - docsSlug: "dialog" -}); -var TitleWarning = ({ titleId }) => { - const titleWarningContext = useWarningContext(TITLE_WARNING_NAME); - const MESSAGE = `\`${titleWarningContext.contentName}\` requires a \`${titleWarningContext.titleName}\` for the component to be accessible for screen reader users. - -If you want to hide the \`${titleWarningContext.titleName}\`, you can wrap it with our VisuallyHidden component. - -For more information, see https://radix-ui.com/primitives/docs/components/${titleWarningContext.docsSlug}`; - React34.useEffect(() => { - if (titleId) { - const hasTitle = document.getElementById(titleId); - if (!hasTitle) console.error(MESSAGE); - } - }, [MESSAGE, titleId]); - return null; -}; -var DESCRIPTION_WARNING_NAME = "DialogDescriptionWarning"; -var DescriptionWarning = ({ contentRef, descriptionId }) => { - const descriptionWarningContext = useWarningContext(DESCRIPTION_WARNING_NAME); - const MESSAGE = `Warning: Missing \`Description\` or \`aria-describedby={undefined}\` for {${descriptionWarningContext.contentName}}.`; - React34.useEffect(() => { - var _a2; - const describedById = (_a2 = contentRef.current) == null ? void 0 : _a2.getAttribute("aria-describedby"); - if (descriptionId && describedById) { - const hasDescription = document.getElementById(descriptionId); - if (!hasDescription) console.warn(MESSAGE); - } - }, [MESSAGE, contentRef, descriptionId]); - return null; -}; -var Root6 = Dialog; -var Trigger3 = DialogTrigger; -var Portal2 = DialogPortal; -var Overlay = DialogOverlay; -var Content3 = DialogContent; -var Title = DialogTitle; -var Description = DialogDescription; -var Close = DialogClose; - -// ../../node_modules/@radix-ui/react-alert-dialog/dist/index.mjs -var import_jsx_runtime15 = __toESM(require_jsx_runtime(), 1); +var React7 = __toESM(require_react(), 1); +var import_jsx_runtime8 = __toESM(require_jsx_runtime(), 1); var ROOT_NAME = "AlertDialog"; var [createAlertDialogContext, createAlertDialogScope] = createContextScope(ROOT_NAME, [ createDialogScope @@ -3326,52 +1173,52 @@ var useDialogScope = createDialogScope(); var AlertDialog = (props) => { const { __scopeAlertDialog, ...alertDialogProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - return (0, import_jsx_runtime15.jsx)(Root6, { ...dialogScope, ...alertDialogProps, modal: true }); + return (0, import_jsx_runtime8.jsx)(Root3, { ...dialogScope, ...alertDialogProps, modal: true }); }; AlertDialog.displayName = ROOT_NAME; -var TRIGGER_NAME4 = "AlertDialogTrigger"; -var AlertDialogTrigger = React35.forwardRef( +var TRIGGER_NAME3 = "AlertDialogTrigger"; +var AlertDialogTrigger = React7.forwardRef( (props, forwardedRef) => { const { __scopeAlertDialog, ...triggerProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - return (0, import_jsx_runtime15.jsx)(Trigger3, { ...dialogScope, ...triggerProps, ref: forwardedRef }); + return (0, import_jsx_runtime8.jsx)(Trigger, { ...dialogScope, ...triggerProps, ref: forwardedRef }); } ); -AlertDialogTrigger.displayName = TRIGGER_NAME4; -var PORTAL_NAME3 = "AlertDialogPortal"; +AlertDialogTrigger.displayName = TRIGGER_NAME3; +var PORTAL_NAME = "AlertDialogPortal"; var AlertDialogPortal = (props) => { const { __scopeAlertDialog, ...portalProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - return (0, import_jsx_runtime15.jsx)(Portal2, { ...dialogScope, ...portalProps }); + return (0, import_jsx_runtime8.jsx)(Portal2, { ...dialogScope, ...portalProps }); }; -AlertDialogPortal.displayName = PORTAL_NAME3; -var OVERLAY_NAME2 = "AlertDialogOverlay"; -var AlertDialogOverlay = React35.forwardRef( +AlertDialogPortal.displayName = PORTAL_NAME; +var OVERLAY_NAME = "AlertDialogOverlay"; +var AlertDialogOverlay = React7.forwardRef( (props, forwardedRef) => { const { __scopeAlertDialog, ...overlayProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - return (0, import_jsx_runtime15.jsx)(Overlay, { ...dialogScope, ...overlayProps, ref: forwardedRef }); + return (0, import_jsx_runtime8.jsx)(Overlay, { ...dialogScope, ...overlayProps, ref: forwardedRef }); } ); -AlertDialogOverlay.displayName = OVERLAY_NAME2; -var CONTENT_NAME4 = "AlertDialogContent"; -var [AlertDialogContentProvider, useAlertDialogContentContext] = createAlertDialogContext(CONTENT_NAME4); -var Slottable2 = createSlottable("AlertDialogContent"); -var AlertDialogContent = React35.forwardRef( +AlertDialogOverlay.displayName = OVERLAY_NAME; +var CONTENT_NAME3 = "AlertDialogContent"; +var [AlertDialogContentProvider, useAlertDialogContentContext] = createAlertDialogContext(CONTENT_NAME3); +var Slottable = createSlottable("AlertDialogContent"); +var AlertDialogContent = React7.forwardRef( (props, forwardedRef) => { const { __scopeAlertDialog, children, ...contentProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - const contentRef = React35.useRef(null); + const contentRef = React7.useRef(null); const composedRefs = useComposedRefs(forwardedRef, contentRef); - const cancelRef = React35.useRef(null); - return (0, import_jsx_runtime15.jsx)( + const cancelRef = React7.useRef(null); + return (0, import_jsx_runtime8.jsx)( WarningProvider, { - contentName: CONTENT_NAME4, - titleName: TITLE_NAME2, + contentName: CONTENT_NAME3, + titleName: TITLE_NAME, docsSlug: "alert-dialog", - children: (0, import_jsx_runtime15.jsx)(AlertDialogContentProvider, { scope: __scopeAlertDialog, cancelRef, children: (0, import_jsx_runtime15.jsxs)( - Content3, + children: (0, import_jsx_runtime8.jsx)(AlertDialogContentProvider, { scope: __scopeAlertDialog, cancelRef, children: (0, import_jsx_runtime8.jsxs)( + Content2, { role: "alertdialog", ...dialogScope, @@ -3385,8 +1232,8 @@ var AlertDialogContent = React35.forwardRef( onPointerDownOutside: (event) => event.preventDefault(), onInteractOutside: (event) => event.preventDefault(), children: [ - (0, import_jsx_runtime15.jsx)(Slottable2, { children }), - (0, import_jsx_runtime15.jsx)(DescriptionWarning2, { contentRef }) + (0, import_jsx_runtime8.jsx)(Slottable, { children }), + (0, import_jsx_runtime8.jsx)(DescriptionWarning, { contentRef }) ] } ) }) @@ -3394,52 +1241,52 @@ var AlertDialogContent = React35.forwardRef( ); } ); -AlertDialogContent.displayName = CONTENT_NAME4; -var TITLE_NAME2 = "AlertDialogTitle"; -var AlertDialogTitle = React35.forwardRef( +AlertDialogContent.displayName = CONTENT_NAME3; +var TITLE_NAME = "AlertDialogTitle"; +var AlertDialogTitle = React7.forwardRef( (props, forwardedRef) => { const { __scopeAlertDialog, ...titleProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - return (0, import_jsx_runtime15.jsx)(Title, { ...dialogScope, ...titleProps, ref: forwardedRef }); + return (0, import_jsx_runtime8.jsx)(Title, { ...dialogScope, ...titleProps, ref: forwardedRef }); } ); -AlertDialogTitle.displayName = TITLE_NAME2; -var DESCRIPTION_NAME2 = "AlertDialogDescription"; -var AlertDialogDescription = React35.forwardRef((props, forwardedRef) => { +AlertDialogTitle.displayName = TITLE_NAME; +var DESCRIPTION_NAME = "AlertDialogDescription"; +var AlertDialogDescription = React7.forwardRef((props, forwardedRef) => { const { __scopeAlertDialog, ...descriptionProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - return (0, import_jsx_runtime15.jsx)(Description, { ...dialogScope, ...descriptionProps, ref: forwardedRef }); + return (0, import_jsx_runtime8.jsx)(Description, { ...dialogScope, ...descriptionProps, ref: forwardedRef }); }); -AlertDialogDescription.displayName = DESCRIPTION_NAME2; +AlertDialogDescription.displayName = DESCRIPTION_NAME; var ACTION_NAME = "AlertDialogAction"; -var AlertDialogAction = React35.forwardRef( +var AlertDialogAction = React7.forwardRef( (props, forwardedRef) => { const { __scopeAlertDialog, ...actionProps } = props; const dialogScope = useDialogScope(__scopeAlertDialog); - return (0, import_jsx_runtime15.jsx)(Close, { ...dialogScope, ...actionProps, ref: forwardedRef }); + return (0, import_jsx_runtime8.jsx)(Close, { ...dialogScope, ...actionProps, ref: forwardedRef }); } ); AlertDialogAction.displayName = ACTION_NAME; var CANCEL_NAME = "AlertDialogCancel"; -var AlertDialogCancel = React35.forwardRef( +var AlertDialogCancel = React7.forwardRef( (props, forwardedRef) => { const { __scopeAlertDialog, ...cancelProps } = props; const { cancelRef } = useAlertDialogContentContext(CANCEL_NAME, __scopeAlertDialog); const dialogScope = useDialogScope(__scopeAlertDialog); const ref = useComposedRefs(forwardedRef, cancelRef); - return (0, import_jsx_runtime15.jsx)(Close, { ...dialogScope, ...cancelProps, ref }); + return (0, import_jsx_runtime8.jsx)(Close, { ...dialogScope, ...cancelProps, ref }); } ); AlertDialogCancel.displayName = CANCEL_NAME; -var DescriptionWarning2 = ({ contentRef }) => { - const MESSAGE = `\`${CONTENT_NAME4}\` requires a description for the component to be accessible for screen reader users. +var DescriptionWarning = ({ contentRef }) => { + const MESSAGE = `\`${CONTENT_NAME3}\` requires a description for the component to be accessible for screen reader users. -You can add a description to the \`${CONTENT_NAME4}\` by passing a \`${DESCRIPTION_NAME2}\` component as a child, which also benefits sighted users by adding visible context to the dialog. +You can add a description to the \`${CONTENT_NAME3}\` by passing a \`${DESCRIPTION_NAME}\` component as a child, which also benefits sighted users by adding visible context to the dialog. -Alternatively, you can use your own component as a description by assigning it an \`id\` and passing the same value to the \`aria-describedby\` prop in \`${CONTENT_NAME4}\`. If the description is confusing or duplicative for sighted users, you can use the \`@radix-ui/react-visually-hidden\` primitive as a wrapper around your description component. +Alternatively, you can use your own component as a description by assigning it an \`id\` and passing the same value to the \`aria-describedby\` prop in \`${CONTENT_NAME3}\`. If the description is confusing or duplicative for sighted users, you can use the \`@radix-ui/react-visually-hidden\` primitive as a wrapper around your description component. For more information, see https://radix-ui.com/primitives/docs/components/alert-dialog`; - React35.useEffect(() => { + React7.useEffect(() => { var _a2; const hasDescription = document.getElementById( (_a2 = contentRef.current) == null ? void 0 : _a2.getAttribute("aria-describedby") @@ -3448,29 +1295,29 @@ For more information, see https://radix-ui.com/primitives/docs/components/alert- }, [MESSAGE, contentRef]); return null; }; -var Root24 = AlertDialog; -var Trigger22 = AlertDialogTrigger; +var Root25 = AlertDialog; +var Trigger23 = AlertDialogTrigger; var Portal22 = AlertDialogPortal; var Overlay2 = AlertDialogOverlay; -var Content22 = AlertDialogContent; +var Content23 = AlertDialogContent; var Action = AlertDialogAction; var Cancel = AlertDialogCancel; var Title2 = AlertDialogTitle; var Description2 = AlertDialogDescription; // ../../node_modules/@radix-ui/react-aspect-ratio/dist/index.mjs -var dist_exports10 = {}; -__export(dist_exports10, { +var dist_exports11 = {}; +__export(dist_exports11, { AspectRatio: () => AspectRatio, - Root: () => Root7 + Root: () => Root6 }); -var React36 = __toESM(require_react(), 1); -var import_jsx_runtime16 = __toESM(require_jsx_runtime(), 1); +var React8 = __toESM(require_react(), 1); +var import_jsx_runtime9 = __toESM(require_jsx_runtime(), 1); var NAME3 = "AspectRatio"; -var AspectRatio = React36.forwardRef( +var AspectRatio = React8.forwardRef( (props, forwardedRef) => { const { ratio = 1 / 1, style, ...aspectRatioProps } = props; - return (0, import_jsx_runtime16.jsx)( + return (0, import_jsx_runtime9.jsx)( "div", { style: { @@ -3481,7 +1328,7 @@ var AspectRatio = React36.forwardRef( paddingBottom: `${100 / ratio}%` }, "data-radix-aspect-ratio-wrapper": "", - children: (0, import_jsx_runtime16.jsx)( + children: (0, import_jsx_runtime9.jsx)( Primitive.div, { ...aspectRatioProps, @@ -3502,20 +1349,20 @@ var AspectRatio = React36.forwardRef( } ); AspectRatio.displayName = NAME3; -var Root7 = AspectRatio; +var Root6 = AspectRatio; // ../../node_modules/@radix-ui/react-avatar/dist/index.mjs -var dist_exports11 = {}; -__export(dist_exports11, { +var dist_exports12 = {}; +__export(dist_exports12, { Avatar: () => Avatar, AvatarFallback: () => AvatarFallback, AvatarImage: () => AvatarImage, Fallback: () => Fallback, Image: () => Image, - Root: () => Root8, + Root: () => Root7, createAvatarScope: () => createAvatarScope }); -var React37 = __toESM(require_react(), 1); +var React9 = __toESM(require_react(), 1); // ../../node_modules/@radix-ui/react-use-is-hydrated/dist/index.mjs var import_shim = __toESM(require_shim(), 1); @@ -3532,28 +1379,28 @@ function subscribe() { } // ../../node_modules/@radix-ui/react-avatar/dist/index.mjs -var import_jsx_runtime17 = __toESM(require_jsx_runtime(), 1); +var import_jsx_runtime10 = __toESM(require_jsx_runtime(), 1); var AVATAR_NAME = "Avatar"; var [createAvatarContext, createAvatarScope] = createContextScope(AVATAR_NAME); var [AvatarProvider, useAvatarContext] = createAvatarContext(AVATAR_NAME); -var Avatar = React37.forwardRef( +var Avatar = React9.forwardRef( (props, forwardedRef) => { const { __scopeAvatar, ...avatarProps } = props; - const [imageLoadingStatus, setImageLoadingStatus] = React37.useState("idle"); - return (0, import_jsx_runtime17.jsx)( + const [imageLoadingStatus, setImageLoadingStatus] = React9.useState("idle"); + return (0, import_jsx_runtime10.jsx)( AvatarProvider, { scope: __scopeAvatar, imageLoadingStatus, onImageLoadingStatusChange: setImageLoadingStatus, - children: (0, import_jsx_runtime17.jsx)(Primitive.span, { ...avatarProps, ref: forwardedRef }) + children: (0, import_jsx_runtime10.jsx)(Primitive.span, { ...avatarProps, ref: forwardedRef }) } ); } ); Avatar.displayName = AVATAR_NAME; var IMAGE_NAME = "AvatarImage"; -var AvatarImage = React37.forwardRef( +var AvatarImage = React9.forwardRef( (props, forwardedRef) => { const { __scopeAvatar, src, onLoadingStatusChange = () => { }, ...imageProps } = props; @@ -3568,23 +1415,23 @@ var AvatarImage = React37.forwardRef( handleLoadingStatusChange(imageLoadingStatus); } }, [imageLoadingStatus, handleLoadingStatusChange]); - return imageLoadingStatus === "loaded" ? (0, import_jsx_runtime17.jsx)(Primitive.img, { ...imageProps, ref: forwardedRef, src }) : null; + return imageLoadingStatus === "loaded" ? (0, import_jsx_runtime10.jsx)(Primitive.img, { ...imageProps, ref: forwardedRef, src }) : null; } ); AvatarImage.displayName = IMAGE_NAME; var FALLBACK_NAME = "AvatarFallback"; -var AvatarFallback = React37.forwardRef( +var AvatarFallback = React9.forwardRef( (props, forwardedRef) => { const { __scopeAvatar, delayMs, ...fallbackProps } = props; const context = useAvatarContext(FALLBACK_NAME, __scopeAvatar); - const [canRender, setCanRender] = React37.useState(delayMs === void 0); - React37.useEffect(() => { + const [canRender, setCanRender] = React9.useState(delayMs === void 0); + React9.useEffect(() => { if (delayMs !== void 0) { const timerId = window.setTimeout(() => setCanRender(true), delayMs); return () => window.clearTimeout(timerId); } }, [delayMs]); - return canRender && context.imageLoadingStatus !== "loaded" ? (0, import_jsx_runtime17.jsx)(Primitive.span, { ...fallbackProps, ref: forwardedRef }) : null; + return canRender && context.imageLoadingStatus !== "loaded" ? (0, import_jsx_runtime10.jsx)(Primitive.span, { ...fallbackProps, ref: forwardedRef }) : null; } ); AvatarFallback.displayName = FALLBACK_NAME; @@ -3602,7 +1449,7 @@ function resolveLoadingStatus(image, src) { } function useImageLoadingStatus(src, { referrerPolicy, crossOrigin }) { const isHydrated = useIsHydrated(); - const imageRef = React37.useRef(null); + const imageRef = React9.useRef(null); const image = (() => { if (!isHydrated) return null; if (!imageRef.current) { @@ -3610,7 +1457,7 @@ function useImageLoadingStatus(src, { referrerPolicy, crossOrigin }) { } return imageRef.current; })(); - const [loadingStatus, setLoadingStatus] = React37.useState( + const [loadingStatus, setLoadingStatus] = React9.useState( () => resolveLoadingStatus(image, src) ); useLayoutEffect2(() => { @@ -3638,13 +1485,13 @@ function useImageLoadingStatus(src, { referrerPolicy, crossOrigin }) { }, [image, crossOrigin, referrerPolicy]); return loadingStatus; } -var Root8 = Avatar; +var Root7 = Avatar; var Image = AvatarImage; var Fallback = AvatarFallback; // ../../node_modules/@radix-ui/react-checkbox/dist/index.mjs -var dist_exports12 = {}; -__export(dist_exports12, { +var dist_exports13 = {}; +__export(dist_exports13, { Checkbox: () => Checkbox, CheckboxIndicator: () => CheckboxIndicator, Indicator: () => CheckboxIndicator, @@ -3657,13 +1504,13 @@ __export(dist_exports12, { unstable_Provider: () => CheckboxProvider, unstable_Trigger: () => CheckboxTrigger }); -var React40 = __toESM(require_react(), 1); +var React11 = __toESM(require_react(), 1); // ../../node_modules/@radix-ui/react-use-previous/dist/index.mjs -var React38 = __toESM(require_react(), 1); +var React10 = __toESM(require_react(), 1); function usePrevious(value) { - const ref = React38.useRef({ value, previous: value }); - return React38.useMemo(() => { + const ref = React10.useRef({ value, previous: value }); + return React10.useMemo(() => { if (ref.current.value !== value) { ref.current.previous = ref.current.value; ref.current.value = value; @@ -3672,45 +1519,8 @@ function usePrevious(value) { }, [value]); } -// ../../node_modules/@radix-ui/react-use-size/dist/index.mjs -var React39 = __toESM(require_react(), 1); -function useSize(element) { - const [size4, setSize] = React39.useState(void 0); - useLayoutEffect2(() => { - if (element) { - setSize({ width: element.offsetWidth, height: element.offsetHeight }); - const resizeObserver = new ResizeObserver((entries) => { - if (!Array.isArray(entries)) { - return; - } - if (!entries.length) { - return; - } - const entry = entries[0]; - let width; - let height; - if ("borderBoxSize" in entry) { - const borderSizeEntry = entry["borderBoxSize"]; - const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry; - width = borderSize["inlineSize"]; - height = borderSize["blockSize"]; - } else { - width = element.offsetWidth; - height = element.offsetHeight; - } - setSize({ width, height }); - }); - resizeObserver.observe(element, { box: "border-box" }); - return () => resizeObserver.unobserve(element); - } else { - setSize(void 0); - } - }, [element]); - return size4; -} - // ../../node_modules/@radix-ui/react-checkbox/dist/index.mjs -var import_jsx_runtime18 = __toESM(require_jsx_runtime(), 1); +var import_jsx_runtime11 = __toESM(require_jsx_runtime(), 1); var CHECKBOX_NAME = "Checkbox"; var [createCheckboxContext, createCheckboxScope] = createContextScope(CHECKBOX_NAME); var [CheckboxProviderImpl, useCheckboxContext] = createCheckboxContext(CHECKBOX_NAME); @@ -3735,9 +1545,9 @@ function CheckboxProvider(props) { onChange: onCheckedChange, caller: CHECKBOX_NAME }); - const [control, setControl] = React40.useState(null); - const [bubbleInput, setBubbleInput] = React40.useState(null); - const hasConsumerStoppedPropagationRef = React40.useRef(false); + const [control, setControl] = React11.useState(null); + const [bubbleInput, setBubbleInput] = React11.useState(null); + const hasConsumerStoppedPropagationRef = React11.useRef(false); const isFormControl2 = control ? !!form || !!control.closest("form") : ( // We set this to true by default so that events bubble to forms without JS (SSR) true @@ -3758,17 +1568,17 @@ function CheckboxProvider(props) { bubbleInput, setBubbleInput }; - return (0, import_jsx_runtime18.jsx)( + return (0, import_jsx_runtime11.jsx)( CheckboxProviderImpl, { scope: __scopeCheckbox, ...context, - children: isFunction2(internal_do_not_use_render) ? internal_do_not_use_render(context) : children + children: isFunction(internal_do_not_use_render) ? internal_do_not_use_render(context) : children } ); } -var TRIGGER_NAME5 = "CheckboxTrigger"; -var CheckboxTrigger = React40.forwardRef( +var TRIGGER_NAME4 = "CheckboxTrigger"; +var CheckboxTrigger = React11.forwardRef( ({ __scopeCheckbox, onKeyDown, onClick, ...checkboxProps }, forwardedRef) => { const { control, @@ -3781,10 +1591,10 @@ var CheckboxTrigger = React40.forwardRef( hasConsumerStoppedPropagationRef, isFormControl: isFormControl2, bubbleInput - } = useCheckboxContext(TRIGGER_NAME5, __scopeCheckbox); + } = useCheckboxContext(TRIGGER_NAME4, __scopeCheckbox); const composedRefs = useComposedRefs(forwardedRef, setControl); - const initialCheckedStateRef = React40.useRef(checked); - React40.useEffect(() => { + const initialCheckedStateRef = React11.useRef(checked); + React11.useEffect(() => { const form = control == null ? void 0 : control.form; if (form) { const reset = () => setChecked(initialCheckedStateRef.current); @@ -3792,14 +1602,14 @@ var CheckboxTrigger = React40.forwardRef( return () => form.removeEventListener("reset", reset); } }, [control, setChecked]); - return (0, import_jsx_runtime18.jsx)( + return (0, import_jsx_runtime11.jsx)( Primitive.button, { type: "button", role: "checkbox", "aria-checked": isIndeterminate(checked) ? "mixed" : checked, "aria-required": required, - "data-state": getState4(checked), + "data-state": getState3(checked), "data-disabled": disabled ? "" : void 0, disabled, value, @@ -3819,8 +1629,8 @@ var CheckboxTrigger = React40.forwardRef( ); } ); -CheckboxTrigger.displayName = TRIGGER_NAME5; -var Checkbox = React40.forwardRef( +CheckboxTrigger.displayName = TRIGGER_NAME4; +var Checkbox = React11.forwardRef( (props, forwardedRef) => { const { __scopeCheckbox, @@ -3834,7 +1644,7 @@ var Checkbox = React40.forwardRef( form, ...checkboxProps } = props; - return (0, import_jsx_runtime18.jsx)( + return (0, import_jsx_runtime11.jsx)( CheckboxProvider, { __scopeCheckbox, @@ -3846,8 +1656,8 @@ var Checkbox = React40.forwardRef( name, form, value, - internal_do_not_use_render: ({ isFormControl: isFormControl2 }) => (0, import_jsx_runtime18.jsxs)(import_jsx_runtime18.Fragment, { children: [ - (0, import_jsx_runtime18.jsx)( + internal_do_not_use_render: ({ isFormControl: isFormControl2 }) => (0, import_jsx_runtime11.jsxs)(import_jsx_runtime11.Fragment, { children: [ + (0, import_jsx_runtime11.jsx)( CheckboxTrigger, { ...checkboxProps, @@ -3855,7 +1665,7 @@ var Checkbox = React40.forwardRef( __scopeCheckbox } ), - isFormControl2 && (0, import_jsx_runtime18.jsx)( + isFormControl2 && (0, import_jsx_runtime11.jsx)( CheckboxBubbleInput, { __scopeCheckbox @@ -3868,18 +1678,18 @@ var Checkbox = React40.forwardRef( ); Checkbox.displayName = CHECKBOX_NAME; var INDICATOR_NAME = "CheckboxIndicator"; -var CheckboxIndicator = React40.forwardRef( +var CheckboxIndicator = React11.forwardRef( (props, forwardedRef) => { const { __scopeCheckbox, forceMount, ...indicatorProps } = props; const context = useCheckboxContext(INDICATOR_NAME, __scopeCheckbox); - return (0, import_jsx_runtime18.jsx)( + return (0, import_jsx_runtime11.jsx)( Presence, { present: forceMount || isIndeterminate(context.checked) || context.checked === true, - children: (0, import_jsx_runtime18.jsx)( + children: (0, import_jsx_runtime11.jsx)( Primitive.span, { - "data-state": getState4(context.checked), + "data-state": getState3(context.checked), "data-disabled": context.disabled ? "" : void 0, ...indicatorProps, ref: forwardedRef, @@ -3892,7 +1702,7 @@ var CheckboxIndicator = React40.forwardRef( ); CheckboxIndicator.displayName = INDICATOR_NAME; var BUBBLE_INPUT_NAME = "CheckboxBubbleInput"; -var CheckboxBubbleInput = React40.forwardRef( +var CheckboxBubbleInput = React11.forwardRef( ({ __scopeCheckbox, ...props }, forwardedRef) => { const { control, @@ -3910,7 +1720,7 @@ var CheckboxBubbleInput = React40.forwardRef( const composedRefs = useComposedRefs(forwardedRef, setBubbleInput); const prevChecked = usePrevious(checked); const controlSize = useSize(control); - React40.useEffect(() => { + React11.useEffect(() => { const input = bubbleInput; if (!input) return; const inputProto = window.HTMLInputElement.prototype; @@ -3927,8 +1737,8 @@ var CheckboxBubbleInput = React40.forwardRef( input.dispatchEvent(event); } }, [bubbleInput, prevChecked, checked, hasConsumerStoppedPropagationRef]); - const defaultCheckedRef = React40.useRef(isIndeterminate(checked) ? false : checked); - return (0, import_jsx_runtime18.jsx)( + const defaultCheckedRef = React11.useRef(isIndeterminate(checked) ? false : checked); + return (0, import_jsx_runtime11.jsx)( Primitive.input, { type: "checkbox", @@ -3959,22 +1769,22 @@ var CheckboxBubbleInput = React40.forwardRef( } ); CheckboxBubbleInput.displayName = BUBBLE_INPUT_NAME; -function isFunction2(value) { +function isFunction(value) { return typeof value === "function"; } function isIndeterminate(checked) { return checked === "indeterminate"; } -function getState4(checked) { +function getState3(checked) { return isIndeterminate(checked) ? "indeterminate" : checked ? "checked" : "unchecked"; } // ../../node_modules/@radix-ui/react-context-menu/dist/index.mjs var dist_exports16 = {}; __export(dist_exports16, { - Arrow: () => Arrow23, + Arrow: () => Arrow22, CheckboxItem: () => CheckboxItem2, - Content: () => Content24, + Content: () => Content25, ContextMenu: () => ContextMenu, ContextMenuArrow: () => ContextMenuArrow, ContextMenuCheckboxItem: () => ContextMenuCheckboxItem, @@ -4003,2248 +1813,19 @@ __export(dist_exports16, { Sub: () => Sub2, SubContent: () => SubContent2, SubTrigger: () => SubTrigger2, - Trigger: () => Trigger4, + Trigger: () => Trigger3, createContextMenuScope: () => createContextMenuScope }); -var React46 = __toESM(require_react(), 1); +var React14 = __toESM(require_react(), 1); // ../../node_modules/@radix-ui/react-menu/dist/index.mjs -var React45 = __toESM(require_react(), 1); - -// ../../node_modules/@radix-ui/react-popper/dist/index.mjs -var React43 = __toESM(require_react(), 1); - -// ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs -var sides = ["top", "right", "bottom", "left"]; -var alignments = ["start", "end"]; -var placements = sides.reduce((acc, side) => acc.concat(side, side + "-" + alignments[0], side + "-" + alignments[1]), []); -var min = Math.min; -var max = Math.max; -var round = Math.round; -var floor = Math.floor; -var createCoords = (v) => ({ - x: v, - y: v -}); -var oppositeSideMap = { - left: "right", - right: "left", - bottom: "top", - top: "bottom" -}; -function clamp(start, value, end) { - return max(start, min(value, end)); -} -function evaluate(value, param) { - return typeof value === "function" ? value(param) : value; -} -function getSide(placement) { - return placement.split("-")[0]; -} -function getAlignment(placement) { - return placement.split("-")[1]; -} -function getOppositeAxis(axis) { - return axis === "x" ? "y" : "x"; -} -function getAxisLength(axis) { - return axis === "y" ? "height" : "width"; -} -function getSideAxis(placement) { - const firstChar = placement[0]; - return firstChar === "t" || firstChar === "b" ? "y" : "x"; -} -function getAlignmentAxis(placement) { - return getOppositeAxis(getSideAxis(placement)); -} -function getAlignmentSides(placement, rects, rtl) { - if (rtl === void 0) { - rtl = false; - } - const alignment = getAlignment(placement); - const alignmentAxis = getAlignmentAxis(placement); - const length = getAxisLength(alignmentAxis); - let mainAlignmentSide = alignmentAxis === "x" ? alignment === (rtl ? "end" : "start") ? "right" : "left" : alignment === "start" ? "bottom" : "top"; - if (rects.reference[length] > rects.floating[length]) { - mainAlignmentSide = getOppositePlacement(mainAlignmentSide); - } - return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)]; -} -function getExpandedPlacements(placement) { - const oppositePlacement = getOppositePlacement(placement); - return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)]; -} -function getOppositeAlignmentPlacement(placement) { - return placement.includes("start") ? placement.replace("start", "end") : placement.replace("end", "start"); -} -var lrPlacement = ["left", "right"]; -var rlPlacement = ["right", "left"]; -var tbPlacement = ["top", "bottom"]; -var btPlacement = ["bottom", "top"]; -function getSideList(side, isStart, rtl) { - switch (side) { - case "top": - case "bottom": - if (rtl) return isStart ? rlPlacement : lrPlacement; - return isStart ? lrPlacement : rlPlacement; - case "left": - case "right": - return isStart ? tbPlacement : btPlacement; - default: - return []; - } -} -function getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) { - const alignment = getAlignment(placement); - let list = getSideList(getSide(placement), direction === "start", rtl); - if (alignment) { - list = list.map((side) => side + "-" + alignment); - if (flipAlignment) { - list = list.concat(list.map(getOppositeAlignmentPlacement)); - } - } - return list; -} -function getOppositePlacement(placement) { - const side = getSide(placement); - return oppositeSideMap[side] + placement.slice(side.length); -} -function expandPaddingObject(padding) { - return { - top: 0, - right: 0, - bottom: 0, - left: 0, - ...padding - }; -} -function getPaddingObject(padding) { - return typeof padding !== "number" ? expandPaddingObject(padding) : { - top: padding, - right: padding, - bottom: padding, - left: padding - }; -} -function rectToClientRect(rect) { - const { - x, - y, - width, - height - } = rect; - return { - width, - height, - top: y, - left: x, - right: x + width, - bottom: y + height, - x, - y - }; -} - -// ../../node_modules/@floating-ui/core/dist/floating-ui.core.mjs -function computeCoordsFromPlacement(_ref, placement, rtl) { - let { - reference, - floating - } = _ref; - const sideAxis = getSideAxis(placement); - const alignmentAxis = getAlignmentAxis(placement); - const alignLength = getAxisLength(alignmentAxis); - const side = getSide(placement); - const isVertical = sideAxis === "y"; - const commonX = reference.x + reference.width / 2 - floating.width / 2; - const commonY = reference.y + reference.height / 2 - floating.height / 2; - const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2; - let coords; - switch (side) { - case "top": - coords = { - x: commonX, - y: reference.y - floating.height - }; - break; - case "bottom": - coords = { - x: commonX, - y: reference.y + reference.height - }; - break; - case "right": - coords = { - x: reference.x + reference.width, - y: commonY - }; - break; - case "left": - coords = { - x: reference.x - floating.width, - y: commonY - }; - break; - default: - coords = { - x: reference.x, - y: reference.y - }; - } - switch (getAlignment(placement)) { - case "start": - coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1); - break; - case "end": - coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1); - break; - } - return coords; -} -async function detectOverflow(state, options) { - var _await$platform$isEle; - if (options === void 0) { - options = {}; - } - const { - x, - y, - platform: platform2, - rects, - elements, - strategy - } = state; - const { - boundary = "clippingAncestors", - rootBoundary = "viewport", - elementContext = "floating", - altBoundary = false, - padding = 0 - } = evaluate(options, state); - const paddingObject = getPaddingObject(padding); - const altContext = elementContext === "floating" ? "reference" : "floating"; - const element = elements[altBoundary ? altContext : elementContext]; - const clippingClientRect = rectToClientRect(await platform2.getClippingRect({ - element: ((_await$platform$isEle = await (platform2.isElement == null ? void 0 : platform2.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || await (platform2.getDocumentElement == null ? void 0 : platform2.getDocumentElement(elements.floating)), - boundary, - rootBoundary, - strategy - })); - const rect = elementContext === "floating" ? { - x, - y, - width: rects.floating.width, - height: rects.floating.height - } : rects.reference; - const offsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(elements.floating)); - const offsetScale = await (platform2.isElement == null ? void 0 : platform2.isElement(offsetParent)) ? await (platform2.getScale == null ? void 0 : platform2.getScale(offsetParent)) || { - x: 1, - y: 1 - } : { - x: 1, - y: 1 - }; - const elementClientRect = rectToClientRect(platform2.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform2.convertOffsetParentRelativeRectToViewportRelativeRect({ - elements, - rect, - offsetParent, - strategy - }) : rect); - return { - top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y, - bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y, - left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x, - right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x - }; -} -var MAX_RESET_COUNT = 50; -var computePosition = async (reference, floating, config) => { - const { - placement = "bottom", - strategy = "absolute", - middleware = [], - platform: platform2 - } = config; - const platformWithDetectOverflow = platform2.detectOverflow ? platform2 : { - ...platform2, - detectOverflow - }; - const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(floating)); - let rects = await platform2.getElementRects({ - reference, - floating, - strategy - }); - let { - x, - y - } = computeCoordsFromPlacement(rects, placement, rtl); - let statefulPlacement = placement; - let resetCount = 0; - const middlewareData = {}; - for (let i = 0; i < middleware.length; i++) { - const currentMiddleware = middleware[i]; - if (!currentMiddleware) { - continue; - } - const { - name, - fn - } = currentMiddleware; - const { - x: nextX, - y: nextY, - data, - reset - } = await fn({ - x, - y, - initialPlacement: placement, - placement: statefulPlacement, - strategy, - middlewareData, - rects, - platform: platformWithDetectOverflow, - elements: { - reference, - floating - } - }); - x = nextX != null ? nextX : x; - y = nextY != null ? nextY : y; - middlewareData[name] = { - ...middlewareData[name], - ...data - }; - if (reset && resetCount < MAX_RESET_COUNT) { - resetCount++; - if (typeof reset === "object") { - if (reset.placement) { - statefulPlacement = reset.placement; - } - if (reset.rects) { - rects = reset.rects === true ? await platform2.getElementRects({ - reference, - floating, - strategy - }) : reset.rects; - } - ({ - x, - y - } = computeCoordsFromPlacement(rects, statefulPlacement, rtl)); - } - i = -1; - } - } - return { - x, - y, - placement: statefulPlacement, - strategy, - middlewareData - }; -}; -var arrow = (options) => ({ - name: "arrow", - options, - async fn(state) { - const { - x, - y, - placement, - rects, - platform: platform2, - elements, - middlewareData - } = state; - const { - element, - padding = 0 - } = evaluate(options, state) || {}; - if (element == null) { - return {}; - } - const paddingObject = getPaddingObject(padding); - const coords = { - x, - y - }; - const axis = getAlignmentAxis(placement); - const length = getAxisLength(axis); - const arrowDimensions = await platform2.getDimensions(element); - const isYAxis = axis === "y"; - const minProp = isYAxis ? "top" : "left"; - const maxProp = isYAxis ? "bottom" : "right"; - const clientProp = isYAxis ? "clientHeight" : "clientWidth"; - const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length]; - const startDiff = coords[axis] - rects.reference[axis]; - const arrowOffsetParent = await (platform2.getOffsetParent == null ? void 0 : platform2.getOffsetParent(element)); - let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0; - if (!clientSize || !await (platform2.isElement == null ? void 0 : platform2.isElement(arrowOffsetParent))) { - clientSize = elements.floating[clientProp] || rects.floating[length]; - } - const centerToReference = endDiff / 2 - startDiff / 2; - const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1; - const minPadding = min(paddingObject[minProp], largestPossiblePadding); - const maxPadding = min(paddingObject[maxProp], largestPossiblePadding); - const min$1 = minPadding; - const max2 = clientSize - arrowDimensions[length] - maxPadding; - const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference; - const offset4 = clamp(min$1, center, max2); - const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset4 && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0; - const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max2 : 0; - return { - [axis]: coords[axis] + alignmentOffset, - data: { - [axis]: offset4, - centerOffset: center - offset4 - alignmentOffset, - ...shouldAddOffset && { - alignmentOffset - } - }, - reset: shouldAddOffset - }; - } -}); -var flip = function(options) { - if (options === void 0) { - options = {}; - } - return { - name: "flip", - options, - async fn(state) { - var _middlewareData$arrow, _middlewareData$flip; - const { - placement, - middlewareData, - rects, - initialPlacement, - platform: platform2, - elements - } = state; - const { - mainAxis: checkMainAxis = true, - crossAxis: checkCrossAxis = true, - fallbackPlacements: specifiedFallbackPlacements, - fallbackStrategy = "bestFit", - fallbackAxisSideDirection = "none", - flipAlignment = true, - ...detectOverflowOptions - } = evaluate(options, state); - if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) { - return {}; - } - const side = getSide(placement); - const initialSideAxis = getSideAxis(initialPlacement); - const isBasePlacement = getSide(initialPlacement) === initialPlacement; - const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)); - const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement)); - const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== "none"; - if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) { - fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl)); - } - const placements2 = [initialPlacement, ...fallbackPlacements]; - const overflow = await platform2.detectOverflow(state, detectOverflowOptions); - const overflows = []; - let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || []; - if (checkMainAxis) { - overflows.push(overflow[side]); - } - if (checkCrossAxis) { - const sides2 = getAlignmentSides(placement, rects, rtl); - overflows.push(overflow[sides2[0]], overflow[sides2[1]]); - } - overflowsData = [...overflowsData, { - placement, - overflows - }]; - if (!overflows.every((side2) => side2 <= 0)) { - var _middlewareData$flip2, _overflowsData$filter; - const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1; - const nextPlacement = placements2[nextIndex]; - if (nextPlacement) { - const ignoreCrossAxisOverflow = checkCrossAxis === "alignment" ? initialSideAxis !== getSideAxis(nextPlacement) : false; - if (!ignoreCrossAxisOverflow || // We leave the current main axis only if every placement on that axis - // overflows the main axis. - overflowsData.every((d) => getSideAxis(d.placement) === initialSideAxis ? d.overflows[0] > 0 : true)) { - return { - data: { - index: nextIndex, - overflows: overflowsData - }, - reset: { - placement: nextPlacement - } - }; - } - } - let resetPlacement = (_overflowsData$filter = overflowsData.filter((d) => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement; - if (!resetPlacement) { - switch (fallbackStrategy) { - case "bestFit": { - var _overflowsData$filter2; - const placement2 = (_overflowsData$filter2 = overflowsData.filter((d) => { - if (hasFallbackAxisSideDirection) { - const currentSideAxis = getSideAxis(d.placement); - return currentSideAxis === initialSideAxis || // Create a bias to the `y` side axis due to horizontal - // reading directions favoring greater width. - currentSideAxis === "y"; - } - return true; - }).map((d) => [d.placement, d.overflows.filter((overflow2) => overflow2 > 0).reduce((acc, overflow2) => acc + overflow2, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0]; - if (placement2) { - resetPlacement = placement2; - } - break; - } - case "initialPlacement": - resetPlacement = initialPlacement; - break; - } - } - if (placement !== resetPlacement) { - return { - reset: { - placement: resetPlacement - } - }; - } - } - return {}; - } - }; -}; -function getSideOffsets(overflow, rect) { - return { - top: overflow.top - rect.height, - right: overflow.right - rect.width, - bottom: overflow.bottom - rect.height, - left: overflow.left - rect.width - }; -} -function isAnySideFullyClipped(overflow) { - return sides.some((side) => overflow[side] >= 0); -} -var hide = function(options) { - if (options === void 0) { - options = {}; - } - return { - name: "hide", - options, - async fn(state) { - const { - rects, - platform: platform2 - } = state; - const { - strategy = "referenceHidden", - ...detectOverflowOptions - } = evaluate(options, state); - switch (strategy) { - case "referenceHidden": { - const overflow = await platform2.detectOverflow(state, { - ...detectOverflowOptions, - elementContext: "reference" - }); - const offsets = getSideOffsets(overflow, rects.reference); - return { - data: { - referenceHiddenOffsets: offsets, - referenceHidden: isAnySideFullyClipped(offsets) - } - }; - } - case "escaped": { - const overflow = await platform2.detectOverflow(state, { - ...detectOverflowOptions, - altBoundary: true - }); - const offsets = getSideOffsets(overflow, rects.floating); - return { - data: { - escapedOffsets: offsets, - escaped: isAnySideFullyClipped(offsets) - } - }; - } - default: { - return {}; - } - } - } - }; -}; -var originSides = /* @__PURE__ */ new Set(["left", "top"]); -async function convertValueToCoords(state, options) { - const { - placement, - platform: platform2, - elements - } = state; - const rtl = await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)); - const side = getSide(placement); - const alignment = getAlignment(placement); - const isVertical = getSideAxis(placement) === "y"; - const mainAxisMulti = originSides.has(side) ? -1 : 1; - const crossAxisMulti = rtl && isVertical ? -1 : 1; - const rawValue = evaluate(options, state); - let { - mainAxis, - crossAxis, - alignmentAxis - } = typeof rawValue === "number" ? { - mainAxis: rawValue, - crossAxis: 0, - alignmentAxis: null - } : { - mainAxis: rawValue.mainAxis || 0, - crossAxis: rawValue.crossAxis || 0, - alignmentAxis: rawValue.alignmentAxis - }; - if (alignment && typeof alignmentAxis === "number") { - crossAxis = alignment === "end" ? alignmentAxis * -1 : alignmentAxis; - } - return isVertical ? { - x: crossAxis * crossAxisMulti, - y: mainAxis * mainAxisMulti - } : { - x: mainAxis * mainAxisMulti, - y: crossAxis * crossAxisMulti - }; -} -var offset = function(options) { - if (options === void 0) { - options = 0; - } - return { - name: "offset", - options, - async fn(state) { - var _middlewareData$offse, _middlewareData$arrow; - const { - x, - y, - placement, - middlewareData - } = state; - const diffCoords = await convertValueToCoords(state, options); - if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) { - return {}; - } - return { - x: x + diffCoords.x, - y: y + diffCoords.y, - data: { - ...diffCoords, - placement - } - }; - } - }; -}; -var shift = function(options) { - if (options === void 0) { - options = {}; - } - return { - name: "shift", - options, - async fn(state) { - const { - x, - y, - placement, - platform: platform2 - } = state; - const { - mainAxis: checkMainAxis = true, - crossAxis: checkCrossAxis = false, - limiter = { - fn: (_ref) => { - let { - x: x2, - y: y2 - } = _ref; - return { - x: x2, - y: y2 - }; - } - }, - ...detectOverflowOptions - } = evaluate(options, state); - const coords = { - x, - y - }; - const overflow = await platform2.detectOverflow(state, detectOverflowOptions); - const crossAxis = getSideAxis(getSide(placement)); - const mainAxis = getOppositeAxis(crossAxis); - let mainAxisCoord = coords[mainAxis]; - let crossAxisCoord = coords[crossAxis]; - if (checkMainAxis) { - const minSide = mainAxis === "y" ? "top" : "left"; - const maxSide = mainAxis === "y" ? "bottom" : "right"; - const min2 = mainAxisCoord + overflow[minSide]; - const max2 = mainAxisCoord - overflow[maxSide]; - mainAxisCoord = clamp(min2, mainAxisCoord, max2); - } - if (checkCrossAxis) { - const minSide = crossAxis === "y" ? "top" : "left"; - const maxSide = crossAxis === "y" ? "bottom" : "right"; - const min2 = crossAxisCoord + overflow[minSide]; - const max2 = crossAxisCoord - overflow[maxSide]; - crossAxisCoord = clamp(min2, crossAxisCoord, max2); - } - const limitedCoords = limiter.fn({ - ...state, - [mainAxis]: mainAxisCoord, - [crossAxis]: crossAxisCoord - }); - return { - ...limitedCoords, - data: { - x: limitedCoords.x - x, - y: limitedCoords.y - y, - enabled: { - [mainAxis]: checkMainAxis, - [crossAxis]: checkCrossAxis - } - } - }; - } - }; -}; -var limitShift = function(options) { - if (options === void 0) { - options = {}; - } - return { - options, - fn(state) { - const { - x, - y, - placement, - rects, - middlewareData - } = state; - const { - offset: offset4 = 0, - mainAxis: checkMainAxis = true, - crossAxis: checkCrossAxis = true - } = evaluate(options, state); - const coords = { - x, - y - }; - const crossAxis = getSideAxis(placement); - const mainAxis = getOppositeAxis(crossAxis); - let mainAxisCoord = coords[mainAxis]; - let crossAxisCoord = coords[crossAxis]; - const rawOffset = evaluate(offset4, state); - const computedOffset = typeof rawOffset === "number" ? { - mainAxis: rawOffset, - crossAxis: 0 - } : { - mainAxis: 0, - crossAxis: 0, - ...rawOffset - }; - if (checkMainAxis) { - const len = mainAxis === "y" ? "height" : "width"; - const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis; - const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis; - if (mainAxisCoord < limitMin) { - mainAxisCoord = limitMin; - } else if (mainAxisCoord > limitMax) { - mainAxisCoord = limitMax; - } - } - if (checkCrossAxis) { - var _middlewareData$offse, _middlewareData$offse2; - const len = mainAxis === "y" ? "width" : "height"; - const isOriginSide = originSides.has(getSide(placement)); - const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis); - const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0); - if (crossAxisCoord < limitMin) { - crossAxisCoord = limitMin; - } else if (crossAxisCoord > limitMax) { - crossAxisCoord = limitMax; - } - } - return { - [mainAxis]: mainAxisCoord, - [crossAxis]: crossAxisCoord - }; - } - }; -}; -var size = function(options) { - if (options === void 0) { - options = {}; - } - return { - name: "size", - options, - async fn(state) { - var _state$middlewareData, _state$middlewareData2; - const { - placement, - rects, - platform: platform2, - elements - } = state; - const { - apply = () => { - }, - ...detectOverflowOptions - } = evaluate(options, state); - const overflow = await platform2.detectOverflow(state, detectOverflowOptions); - const side = getSide(placement); - const alignment = getAlignment(placement); - const isYAxis = getSideAxis(placement) === "y"; - const { - width, - height - } = rects.floating; - let heightSide; - let widthSide; - if (side === "top" || side === "bottom") { - heightSide = side; - widthSide = alignment === (await (platform2.isRTL == null ? void 0 : platform2.isRTL(elements.floating)) ? "start" : "end") ? "left" : "right"; - } else { - widthSide = side; - heightSide = alignment === "end" ? "top" : "bottom"; - } - const maximumClippingHeight = height - overflow.top - overflow.bottom; - const maximumClippingWidth = width - overflow.left - overflow.right; - const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight); - const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth); - const noShift = !state.middlewareData.shift; - let availableHeight = overflowAvailableHeight; - let availableWidth = overflowAvailableWidth; - if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) { - availableWidth = maximumClippingWidth; - } - if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) { - availableHeight = maximumClippingHeight; - } - if (noShift && !alignment) { - const xMin = max(overflow.left, 0); - const xMax = max(overflow.right, 0); - const yMin = max(overflow.top, 0); - const yMax = max(overflow.bottom, 0); - if (isYAxis) { - availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right)); - } else { - availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom)); - } - } - await apply({ - ...state, - availableWidth, - availableHeight - }); - const nextDimensions = await platform2.getDimensions(elements.floating); - if (width !== nextDimensions.width || height !== nextDimensions.height) { - return { - reset: { - rects: true - } - }; - } - return {}; - } - }; -}; - -// ../../node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs -function hasWindow() { - return typeof window !== "undefined"; -} -function getNodeName(node) { - if (isNode2(node)) { - return (node.nodeName || "").toLowerCase(); - } - return "#document"; -} -function getWindow(node) { - var _node$ownerDocument; - return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window; -} -function getDocumentElement(node) { - var _ref; - return (_ref = (isNode2(node) ? node.ownerDocument : node.document) || window.document) == null ? void 0 : _ref.documentElement; -} -function isNode2(value) { - if (!hasWindow()) { - return false; - } - return value instanceof Node || value instanceof getWindow(value).Node; -} -function isElement(value) { - if (!hasWindow()) { - return false; - } - return value instanceof Element || value instanceof getWindow(value).Element; -} -function isHTMLElement(value) { - if (!hasWindow()) { - return false; - } - return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement; -} -function isShadowRoot(value) { - if (!hasWindow() || typeof ShadowRoot === "undefined") { - return false; - } - return value instanceof ShadowRoot || value instanceof getWindow(value).ShadowRoot; -} -function isOverflowElement(element) { - const { - overflow, - overflowX, - overflowY, - display - } = getComputedStyle2(element); - return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && display !== "inline" && display !== "contents"; -} -function isTableElement(element) { - return /^(table|td|th)$/.test(getNodeName(element)); -} -function isTopLayer(element) { - try { - if (element.matches(":popover-open")) { - return true; - } - } catch (_e) { - } - try { - return element.matches(":modal"); - } catch (_e) { - return false; - } -} -var willChangeRe = /transform|translate|scale|rotate|perspective|filter/; -var containRe = /paint|layout|strict|content/; -var isNotNone = (value) => !!value && value !== "none"; -var isWebKitValue; -function isContainingBlock(elementOrCss) { - const css = isElement(elementOrCss) ? getComputedStyle2(elementOrCss) : elementOrCss; - return isNotNone(css.transform) || isNotNone(css.translate) || isNotNone(css.scale) || isNotNone(css.rotate) || isNotNone(css.perspective) || !isWebKit() && (isNotNone(css.backdropFilter) || isNotNone(css.filter)) || willChangeRe.test(css.willChange || "") || containRe.test(css.contain || ""); -} -function getContainingBlock(element) { - let currentNode = getParentNode(element); - while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) { - if (isContainingBlock(currentNode)) { - return currentNode; - } else if (isTopLayer(currentNode)) { - return null; - } - currentNode = getParentNode(currentNode); - } - return null; -} -function isWebKit() { - if (isWebKitValue == null) { - isWebKitValue = typeof CSS !== "undefined" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none"); - } - return isWebKitValue; -} -function isLastTraversableNode(node) { - return /^(html|body|#document)$/.test(getNodeName(node)); -} -function getComputedStyle2(element) { - return getWindow(element).getComputedStyle(element); -} -function getNodeScroll(element) { - if (isElement(element)) { - return { - scrollLeft: element.scrollLeft, - scrollTop: element.scrollTop - }; - } - return { - scrollLeft: element.scrollX, - scrollTop: element.scrollY - }; -} -function getParentNode(node) { - if (getNodeName(node) === "html") { - return node; - } - const result = ( - // Step into the shadow DOM of the parent of a slotted node. - node.assignedSlot || // DOM Element detected. - node.parentNode || // ShadowRoot detected. - isShadowRoot(node) && node.host || // Fallback. - getDocumentElement(node) - ); - return isShadowRoot(result) ? result.host : result; -} -function getNearestOverflowAncestor(node) { - const parentNode = getParentNode(node); - if (isLastTraversableNode(parentNode)) { - return node.ownerDocument ? node.ownerDocument.body : node.body; - } - if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) { - return parentNode; - } - return getNearestOverflowAncestor(parentNode); -} -function getOverflowAncestors(node, list, traverseIframes) { - var _node$ownerDocument2; - if (list === void 0) { - list = []; - } - if (traverseIframes === void 0) { - traverseIframes = true; - } - const scrollableAncestor = getNearestOverflowAncestor(node); - const isBody = scrollableAncestor === ((_node$ownerDocument2 = node.ownerDocument) == null ? void 0 : _node$ownerDocument2.body); - const win = getWindow(scrollableAncestor); - if (isBody) { - const frameElement = getFrameElement(win); - return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : [], frameElement && traverseIframes ? getOverflowAncestors(frameElement) : []); - } else { - return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor, [], traverseIframes)); - } -} -function getFrameElement(win) { - return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null; -} - -// ../../node_modules/@floating-ui/dom/dist/floating-ui.dom.mjs -function getCssDimensions(element) { - const css = getComputedStyle2(element); - let width = parseFloat(css.width) || 0; - let height = parseFloat(css.height) || 0; - const hasOffset = isHTMLElement(element); - const offsetWidth = hasOffset ? element.offsetWidth : width; - const offsetHeight = hasOffset ? element.offsetHeight : height; - const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight; - if (shouldFallback) { - width = offsetWidth; - height = offsetHeight; - } - return { - width, - height, - $: shouldFallback - }; -} -function unwrapElement(element) { - return !isElement(element) ? element.contextElement : element; -} -function getScale(element) { - const domElement = unwrapElement(element); - if (!isHTMLElement(domElement)) { - return createCoords(1); - } - const rect = domElement.getBoundingClientRect(); - const { - width, - height, - $ - } = getCssDimensions(domElement); - let x = ($ ? round(rect.width) : rect.width) / width; - let y = ($ ? round(rect.height) : rect.height) / height; - if (!x || !Number.isFinite(x)) { - x = 1; - } - if (!y || !Number.isFinite(y)) { - y = 1; - } - return { - x, - y - }; -} -var noOffsets = createCoords(0); -function getVisualOffsets(element) { - const win = getWindow(element); - if (!isWebKit() || !win.visualViewport) { - return noOffsets; - } - return { - x: win.visualViewport.offsetLeft, - y: win.visualViewport.offsetTop - }; -} -function shouldAddVisualOffsets(element, isFixed, floatingOffsetParent) { - if (isFixed === void 0) { - isFixed = false; - } - if (!floatingOffsetParent || isFixed && floatingOffsetParent !== getWindow(element)) { - return false; - } - return isFixed; -} -function getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) { - if (includeScale === void 0) { - includeScale = false; - } - if (isFixedStrategy === void 0) { - isFixedStrategy = false; - } - const clientRect = element.getBoundingClientRect(); - const domElement = unwrapElement(element); - let scale = createCoords(1); - if (includeScale) { - if (offsetParent) { - if (isElement(offsetParent)) { - scale = getScale(offsetParent); - } - } else { - scale = getScale(element); - } - } - const visualOffsets = shouldAddVisualOffsets(domElement, isFixedStrategy, offsetParent) ? getVisualOffsets(domElement) : createCoords(0); - let x = (clientRect.left + visualOffsets.x) / scale.x; - let y = (clientRect.top + visualOffsets.y) / scale.y; - let width = clientRect.width / scale.x; - let height = clientRect.height / scale.y; - if (domElement) { - const win = getWindow(domElement); - const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent; - let currentWin = win; - let currentIFrame = getFrameElement(currentWin); - while (currentIFrame && offsetParent && offsetWin !== currentWin) { - const iframeScale = getScale(currentIFrame); - const iframeRect = currentIFrame.getBoundingClientRect(); - const css = getComputedStyle2(currentIFrame); - const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x; - const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y; - x *= iframeScale.x; - y *= iframeScale.y; - width *= iframeScale.x; - height *= iframeScale.y; - x += left; - y += top; - currentWin = getWindow(currentIFrame); - currentIFrame = getFrameElement(currentWin); - } - } - return rectToClientRect({ - width, - height, - x, - y - }); -} -function getWindowScrollBarX(element, rect) { - const leftScroll = getNodeScroll(element).scrollLeft; - if (!rect) { - return getBoundingClientRect(getDocumentElement(element)).left + leftScroll; - } - return rect.left + leftScroll; -} -function getHTMLOffset(documentElement, scroll) { - const htmlRect = documentElement.getBoundingClientRect(); - const x = htmlRect.left + scroll.scrollLeft - getWindowScrollBarX(documentElement, htmlRect); - const y = htmlRect.top + scroll.scrollTop; - return { - x, - y - }; -} -function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) { - let { - elements, - rect, - offsetParent, - strategy - } = _ref; - const isFixed = strategy === "fixed"; - const documentElement = getDocumentElement(offsetParent); - const topLayer = elements ? isTopLayer(elements.floating) : false; - if (offsetParent === documentElement || topLayer && isFixed) { - return rect; - } - let scroll = { - scrollLeft: 0, - scrollTop: 0 - }; - let scale = createCoords(1); - const offsets = createCoords(0); - const isOffsetParentAnElement = isHTMLElement(offsetParent); - if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { - if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) { - scroll = getNodeScroll(offsetParent); - } - if (isOffsetParentAnElement) { - const offsetRect = getBoundingClientRect(offsetParent); - scale = getScale(offsetParent); - offsets.x = offsetRect.x + offsetParent.clientLeft; - offsets.y = offsetRect.y + offsetParent.clientTop; - } - } - const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0); - return { - width: rect.width * scale.x, - height: rect.height * scale.y, - x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x + htmlOffset.x, - y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y + htmlOffset.y - }; -} -function getClientRects(element) { - return Array.from(element.getClientRects()); -} -function getDocumentRect(element) { - const html = getDocumentElement(element); - const scroll = getNodeScroll(element); - const body = element.ownerDocument.body; - const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth); - const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight); - let x = -scroll.scrollLeft + getWindowScrollBarX(element); - const y = -scroll.scrollTop; - if (getComputedStyle2(body).direction === "rtl") { - x += max(html.clientWidth, body.clientWidth) - width; - } - return { - width, - height, - x, - y - }; -} -var SCROLLBAR_MAX = 25; -function getViewportRect(element, strategy) { - const win = getWindow(element); - const html = getDocumentElement(element); - const visualViewport = win.visualViewport; - let width = html.clientWidth; - let height = html.clientHeight; - let x = 0; - let y = 0; - if (visualViewport) { - width = visualViewport.width; - height = visualViewport.height; - const visualViewportBased = isWebKit(); - if (!visualViewportBased || visualViewportBased && strategy === "fixed") { - x = visualViewport.offsetLeft; - y = visualViewport.offsetTop; - } - } - const windowScrollbarX = getWindowScrollBarX(html); - if (windowScrollbarX <= 0) { - const doc = html.ownerDocument; - const body = doc.body; - const bodyStyles = getComputedStyle(body); - const bodyMarginInline = doc.compatMode === "CSS1Compat" ? parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight) || 0 : 0; - const clippingStableScrollbarWidth = Math.abs(html.clientWidth - body.clientWidth - bodyMarginInline); - if (clippingStableScrollbarWidth <= SCROLLBAR_MAX) { - width -= clippingStableScrollbarWidth; - } - } else if (windowScrollbarX <= SCROLLBAR_MAX) { - width += windowScrollbarX; - } - return { - width, - height, - x, - y - }; -} -function getInnerBoundingClientRect(element, strategy) { - const clientRect = getBoundingClientRect(element, true, strategy === "fixed"); - const top = clientRect.top + element.clientTop; - const left = clientRect.left + element.clientLeft; - const scale = isHTMLElement(element) ? getScale(element) : createCoords(1); - const width = element.clientWidth * scale.x; - const height = element.clientHeight * scale.y; - const x = left * scale.x; - const y = top * scale.y; - return { - width, - height, - x, - y - }; -} -function getClientRectFromClippingAncestor(element, clippingAncestor, strategy) { - let rect; - if (clippingAncestor === "viewport") { - rect = getViewportRect(element, strategy); - } else if (clippingAncestor === "document") { - rect = getDocumentRect(getDocumentElement(element)); - } else if (isElement(clippingAncestor)) { - rect = getInnerBoundingClientRect(clippingAncestor, strategy); - } else { - const visualOffsets = getVisualOffsets(element); - rect = { - x: clippingAncestor.x - visualOffsets.x, - y: clippingAncestor.y - visualOffsets.y, - width: clippingAncestor.width, - height: clippingAncestor.height - }; - } - return rectToClientRect(rect); -} -function hasFixedPositionAncestor(element, stopNode) { - const parentNode = getParentNode(element); - if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) { - return false; - } - return getComputedStyle2(parentNode).position === "fixed" || hasFixedPositionAncestor(parentNode, stopNode); -} -function getClippingElementAncestors(element, cache) { - const cachedResult = cache.get(element); - if (cachedResult) { - return cachedResult; - } - let result = getOverflowAncestors(element, [], false).filter((el) => isElement(el) && getNodeName(el) !== "body"); - let currentContainingBlockComputedStyle = null; - const elementIsFixed = getComputedStyle2(element).position === "fixed"; - let currentNode = elementIsFixed ? getParentNode(element) : element; - while (isElement(currentNode) && !isLastTraversableNode(currentNode)) { - const computedStyle = getComputedStyle2(currentNode); - const currentNodeIsContaining = isContainingBlock(currentNode); - if (!currentNodeIsContaining && computedStyle.position === "fixed") { - currentContainingBlockComputedStyle = null; - } - const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === "static" && !!currentContainingBlockComputedStyle && (currentContainingBlockComputedStyle.position === "absolute" || currentContainingBlockComputedStyle.position === "fixed") || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode); - if (shouldDropCurrentNode) { - result = result.filter((ancestor) => ancestor !== currentNode); - } else { - currentContainingBlockComputedStyle = computedStyle; - } - currentNode = getParentNode(currentNode); - } - cache.set(element, result); - return result; -} -function getClippingRect(_ref) { - let { - element, - boundary, - rootBoundary, - strategy - } = _ref; - const elementClippingAncestors = boundary === "clippingAncestors" ? isTopLayer(element) ? [] : getClippingElementAncestors(element, this._c) : [].concat(boundary); - const clippingAncestors = [...elementClippingAncestors, rootBoundary]; - const firstRect = getClientRectFromClippingAncestor(element, clippingAncestors[0], strategy); - let top = firstRect.top; - let right = firstRect.right; - let bottom = firstRect.bottom; - let left = firstRect.left; - for (let i = 1; i < clippingAncestors.length; i++) { - const rect = getClientRectFromClippingAncestor(element, clippingAncestors[i], strategy); - top = max(rect.top, top); - right = min(rect.right, right); - bottom = min(rect.bottom, bottom); - left = max(rect.left, left); - } - return { - width: right - left, - height: bottom - top, - x: left, - y: top - }; -} -function getDimensions(element) { - const { - width, - height - } = getCssDimensions(element); - return { - width, - height - }; -} -function getRectRelativeToOffsetParent(element, offsetParent, strategy) { - const isOffsetParentAnElement = isHTMLElement(offsetParent); - const documentElement = getDocumentElement(offsetParent); - const isFixed = strategy === "fixed"; - const rect = getBoundingClientRect(element, true, isFixed, offsetParent); - let scroll = { - scrollLeft: 0, - scrollTop: 0 - }; - const offsets = createCoords(0); - function setLeftRTLScrollbarOffset() { - offsets.x = getWindowScrollBarX(documentElement); - } - if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { - if (getNodeName(offsetParent) !== "body" || isOverflowElement(documentElement)) { - scroll = getNodeScroll(offsetParent); - } - if (isOffsetParentAnElement) { - const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent); - offsets.x = offsetRect.x + offsetParent.clientLeft; - offsets.y = offsetRect.y + offsetParent.clientTop; - } else if (documentElement) { - setLeftRTLScrollbarOffset(); - } - } - if (isFixed && !isOffsetParentAnElement && documentElement) { - setLeftRTLScrollbarOffset(); - } - const htmlOffset = documentElement && !isOffsetParentAnElement && !isFixed ? getHTMLOffset(documentElement, scroll) : createCoords(0); - const x = rect.left + scroll.scrollLeft - offsets.x - htmlOffset.x; - const y = rect.top + scroll.scrollTop - offsets.y - htmlOffset.y; - return { - x, - y, - width: rect.width, - height: rect.height - }; -} -function isStaticPositioned(element) { - return getComputedStyle2(element).position === "static"; -} -function getTrueOffsetParent(element, polyfill) { - if (!isHTMLElement(element) || getComputedStyle2(element).position === "fixed") { - return null; - } - if (polyfill) { - return polyfill(element); - } - let rawOffsetParent = element.offsetParent; - if (getDocumentElement(element) === rawOffsetParent) { - rawOffsetParent = rawOffsetParent.ownerDocument.body; - } - return rawOffsetParent; -} -function getOffsetParent(element, polyfill) { - const win = getWindow(element); - if (isTopLayer(element)) { - return win; - } - if (!isHTMLElement(element)) { - let svgOffsetParent = getParentNode(element); - while (svgOffsetParent && !isLastTraversableNode(svgOffsetParent)) { - if (isElement(svgOffsetParent) && !isStaticPositioned(svgOffsetParent)) { - return svgOffsetParent; - } - svgOffsetParent = getParentNode(svgOffsetParent); - } - return win; - } - let offsetParent = getTrueOffsetParent(element, polyfill); - while (offsetParent && isTableElement(offsetParent) && isStaticPositioned(offsetParent)) { - offsetParent = getTrueOffsetParent(offsetParent, polyfill); - } - if (offsetParent && isLastTraversableNode(offsetParent) && isStaticPositioned(offsetParent) && !isContainingBlock(offsetParent)) { - return win; - } - return offsetParent || getContainingBlock(element) || win; -} -var getElementRects = async function(data) { - const getOffsetParentFn = this.getOffsetParent || getOffsetParent; - const getDimensionsFn = this.getDimensions; - const floatingDimensions = await getDimensionsFn(data.floating); - return { - reference: getRectRelativeToOffsetParent(data.reference, await getOffsetParentFn(data.floating), data.strategy), - floating: { - x: 0, - y: 0, - width: floatingDimensions.width, - height: floatingDimensions.height - } - }; -}; -function isRTL(element) { - return getComputedStyle2(element).direction === "rtl"; -} -var platform = { - convertOffsetParentRelativeRectToViewportRelativeRect, - getDocumentElement, - getClippingRect, - getOffsetParent, - getElementRects, - getClientRects, - getDimensions, - getScale, - isElement, - isRTL -}; -function rectsAreEqual(a, b) { - return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height; -} -function observeMove(element, onMove) { - let io = null; - let timeoutId; - const root = getDocumentElement(element); - function cleanup() { - var _io; - clearTimeout(timeoutId); - (_io = io) == null || _io.disconnect(); - io = null; - } - function refresh(skip, threshold) { - if (skip === void 0) { - skip = false; - } - if (threshold === void 0) { - threshold = 1; - } - cleanup(); - const elementRectForRootMargin = element.getBoundingClientRect(); - const { - left, - top, - width, - height - } = elementRectForRootMargin; - if (!skip) { - onMove(); - } - if (!width || !height) { - return; - } - const insetTop = floor(top); - const insetRight = floor(root.clientWidth - (left + width)); - const insetBottom = floor(root.clientHeight - (top + height)); - const insetLeft = floor(left); - const rootMargin = -insetTop + "px " + -insetRight + "px " + -insetBottom + "px " + -insetLeft + "px"; - const options = { - rootMargin, - threshold: max(0, min(1, threshold)) || 1 - }; - let isFirstUpdate = true; - function handleObserve(entries) { - const ratio = entries[0].intersectionRatio; - if (ratio !== threshold) { - if (!isFirstUpdate) { - return refresh(); - } - if (!ratio) { - timeoutId = setTimeout(() => { - refresh(false, 1e-7); - }, 1e3); - } else { - refresh(false, ratio); - } - } - if (ratio === 1 && !rectsAreEqual(elementRectForRootMargin, element.getBoundingClientRect())) { - refresh(); - } - isFirstUpdate = false; - } - try { - io = new IntersectionObserver(handleObserve, { - ...options, - // Handle