@cedros/data-react 0.1.0

package/dist/admin/sections/PagesSection.js

@@ -0,0 +1,157 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { requestJson } from "../api.js";
+import { AdminButton, Card, JsonEditor, StatusNotice } from "../components.js";
+export default function PagesSection({ pluginContext }) {
+    const canWritePages = pluginContext.hasPermission("data:pages:write");
+    const canBootstrap = pluginContext.hasPermission("data:ops:write");
+    const [templates, setTemplates] = useState([]);
+    const [entries, setEntries] = useState([]);
+    const [activePageKey, setActivePageKey] = useState("");
+    const [payloadEditor, setPayloadEditor] = useState("{}");
+    const [status, setStatus] = useState("");
+    const [statusTone, setStatusTone] = useState("neutral");
+    const [loading, setLoading] = useState(false);
+    const load = useCallback(async () => {
+        setLoading(true);
+        setStatus("");
+        setStatusTone("neutral");
+        try {
+            const [templateData, pageData] = await Promise.all([
+                requestJson(pluginContext, "/admin/default-pages"),
+                requestJson(pluginContext, "/admin/pages")
+            ]);
+            setTemplates(templateData);
+            setEntries(pageData);
+            const firstKey = pageData[0]?.entry_key ?? templateData[0]?.key ?? "";
+            const knownKeys = new Set([
+                ...pageData.map((entry) => entry.entry_key),
+                ...templateData.map((template) => template.key)
+            ]);
+            setActivePageKey((current) => (current && knownKeys.has(current) ? current : firstKey));
+        }
+        catch (error) {
+            setStatus(error.message);
+            setStatusTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [pluginContext]);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const activePayload = useMemo(() => {
+        const existing = entries.find((entry) => entry.entry_key === activePageKey);
+        if (existing) {
+            return existing.payload;
+        }
+        const fallback = templates.find((template) => template.key === activePageKey);
+        if (!fallback) {
+            return null;
+        }
+        return buildDefaultPagePayload(fallback);
+    }, [activePageKey, entries, templates]);
+    const activeTemplate = useMemo(() => templates.find((template) => template.key === activePageKey) ?? null, [activePageKey, templates]);
+    const activeEntry = useMemo(() => entries.find((entry) => entry.entry_key === activePageKey) ?? null, [activePageKey, entries]);
+    useEffect(() => {
+        if (!activePayload) {
+            return;
+        }
+        setPayloadEditor(JSON.stringify(activePayload, null, 2));
+    }, [activePayload]);
+    const save = useCallback(async () => {
+        if (!canWritePages) {
+            setStatus("You do not have permission to edit pages.");
+            setStatusTone("error");
+            return;
+        }
+        if (!activePageKey) {
+            setStatus("Select a page first.");
+            setStatusTone("error");
+            return;
+        }
+        let payload;
+        try {
+            const parsed = JSON.parse(payloadEditor);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+                throw new Error("Page payload must be a JSON object");
+            }
+            payload = parsed;
+        }
+        catch (error) {
+            setStatus(`Invalid JSON: ${error.message}`);
+            setStatusTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setStatusTone("neutral");
+        try {
+            await requestJson(pluginContext, `/admin/pages/${encodeURIComponent(activePageKey)}`, {
+                method: "PUT",
+                body: { payload }
+            });
+            setStatus("Page saved.");
+            setStatusTone("success");
+            await load();
+        }
+        catch (error) {
+            setStatus(error.message);
+            setStatusTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [activePageKey, canWritePages, load, payloadEditor, pluginContext]);
+    const bootstrap = useCallback(async () => {
+        if (!canBootstrap) {
+            setStatus("You do not have permission to initialize defaults.");
+            setStatusTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setStatusTone("neutral");
+        try {
+            await requestJson(pluginContext, "/admin/bootstrap", {
+                method: "POST"
+            });
+            setStatus("Defaults initialized.");
+            setStatusTone("success");
+            await load();
+        }
+        catch (error) {
+            setStatus(error.message);
+            setStatusTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [canBootstrap, load, pluginContext]);
+    const resetActivePage = useCallback(() => {
+        if (!activeTemplate) {
+            return;
+        }
+        setPayloadEditor(JSON.stringify(buildDefaultPagePayload(activeTemplate), null, 2));
+        setStatus("Editor reset to template default payload.");
+        setStatusTone("neutral");
+    }, [activeTemplate]);
+    return (_jsxs("div", { className: "cedros-data", children: [_jsxs("header", { className: "cedros-data__header", children: [_jsxs("div", { children: [_jsx("h2", { className: "cedros-data__title", children: "Pages" }), _jsx("p", { className: "cedros-data__subtitle", children: "Edit the JSON payloads for the default page set." }), !canWritePages && (_jsx("p", { className: "cedros-data__subtitle", children: "Read-only mode. Missing `data:pages:write` permission." }))] }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", onClick: () => void bootstrap(), disabled: loading || !canBootstrap, title: !canBootstrap ? "Requires data:ops:write" : undefined, children: "Initialize Defaults" }), _jsx(AdminButton, { variant: "secondary", onClick: resetActivePage, disabled: !activeTemplate, children: "Reset Payload" }), _jsx(AdminButton, { variant: "primary", onClick: () => void save(), disabled: loading || !activePageKey || !canWritePages, title: !canWritePages ? "Requires data:pages:write" : undefined, children: "Save Page" })] })] }), _jsxs("div", { className: "cedros-data-grid cedros-data-grid--page", children: [_jsx(Card, { title: `Default Pages (${templates.length})`, subtitle: "Core pages available for this site.", children: _jsxs("div", { className: "cedros-data-list", children: [templates.length === 0 && _jsx("div", { className: "cedros-data-empty", children: "No templates registered." }), templates.map((template) => {
+                                    const selected = template.key === activePageKey;
+                                    return (_jsx("button", { className: `cedros-data-list-item ${selected ? "cedros-data-list-item--active" : ""}`, onClick: () => setActivePageKey(template.key), children: template.title }, template.key));
+                                })] }) }), _jsx(Card, { title: activeTemplate?.title ?? "Select a page", subtitle: activeTemplate
+                            ? `${activeTemplate.route} • ${activeTemplate.section}`
+                            : "Choose a page to edit its payload.", actions: activeEntry ? (_jsxs("span", { className: "cedros-data-key", children: ["updated: ", new Date(activeEntry.updated_at).toLocaleString()] })) : undefined, children: _jsx(JsonEditor, { label: "Page Payload", value: payloadEditor, onChange: (event) => setPayloadEditor(event.target.value), disabled: !activePageKey || !canWritePages }) })] }), status && _jsx(StatusNotice, { tone: statusTone, message: status })] }));
+}
+function buildDefaultPagePayload(template) {
+    return {
+        key: template.key,
+        title: template.title,
+        route: template.route,
+        section: template.section,
+        status: "draft",
+        meta: {},
+        blocks: []
+    };
+}

package/dist/admin/sections/SchemaDesignerSection.d.ts

@@ -0,0 +1,2 @@
+import type { AdminSectionProps } from "../types.js";
+export default function SchemaDesignerSection({ pluginContext }: AdminSectionProps): React.JSX.Element;

package/dist/admin/sections/SchemaDesignerSection.js

@@ -0,0 +1,167 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo, useState } from "react";
+import { requestJson } from "../api.js";
+import { AdminButton, Card, JsonEditor, StatusNotice } from "../components.js";
+const EMPTY_SCHEMA = {
+    types: [],
+    tables: []
+};
+export default function SchemaDesignerSection({ pluginContext }) {
+    const canLoadCurrentSchema = pluginContext.hasPermission("data:ops:write");
+    const canWriteSchema = pluginContext.hasPermission("data:schema:write");
+    const [currentSchema, setCurrentSchema] = useState(EMPTY_SCHEMA);
+    const [proposalEditor, setProposalEditor] = useState(JSON.stringify(EMPTY_SCHEMA, null, 2));
+    const [latestReport, setLatestReport] = useState(null);
+    const [status, setStatus] = useState("");
+    const [tone, setTone] = useState("neutral");
+    const [loading, setLoading] = useState(false);
+    const loadCurrent = useCallback(async () => {
+        if (!canLoadCurrentSchema) {
+            setStatus("You do not have permission to load the current schema.");
+            setTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            const exportPayload = await requestJson(pluginContext, "/site/export");
+            const parsed = normalizeSchemaDefinition(exportPayload.custom_schema);
+            setCurrentSchema(parsed);
+            setProposalEditor(JSON.stringify(parsed, null, 2));
+            setLatestReport(null);
+            setStatus("Current schema loaded.");
+            setTone("success");
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [canLoadCurrentSchema, pluginContext]);
+    const proposalSchema = useMemo(() => {
+        try {
+            return normalizeSchemaDefinition(JSON.parse(proposalEditor));
+        }
+        catch (_error) {
+            return null;
+        }
+    }, [proposalEditor]);
+    const diff = useMemo(() => {
+        if (!proposalSchema) {
+            return {
+                additive: [],
+                breaking: [],
+                warnings: ["Proposed schema JSON is invalid."]
+            };
+        }
+        return summarizeDiff(currentSchema, proposalSchema);
+    }, [currentSchema, proposalSchema]);
+    const applySchema = useCallback(async () => {
+        if (!canWriteSchema) {
+            setStatus("You do not have permission to apply schema changes.");
+            setTone("error");
+            return;
+        }
+        if (!proposalSchema) {
+            setStatus("Cannot apply invalid schema JSON.");
+            setTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            const report = await requestJson(pluginContext, "/custom-schema", {
+                method: "POST",
+                body: {
+                    definition: proposalSchema
+                }
+            });
+            setLatestReport(report);
+            if (!report.applied) {
+                setStatus(`Schema blocked due to breaking changes: ${report.breaking_changes.join(", ") || "unknown"}`);
+                setTone("error");
+                return;
+            }
+            setCurrentSchema(proposalSchema);
+            setStatus(`Custom schema applied (version ${report.version}).`);
+            setTone("success");
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [canWriteSchema, pluginContext, proposalSchema]);
+    const resetProposal = useCallback(() => {
+        setProposalEditor(JSON.stringify(currentSchema, null, 2));
+        setStatus("Proposal reset to current schema.");
+        setTone("neutral");
+    }, [currentSchema]);
+    return (_jsxs("div", { className: "cedros-data", children: [_jsxs("header", { className: "cedros-data__header", children: [_jsxs("div", { children: [_jsx("h2", { className: "cedros-data__title", children: "Schema Designer" }), _jsx("p", { className: "cedros-data__subtitle", children: "Design additive custom schema migrations for this deployment." }), !canLoadCurrentSchema && (_jsx("p", { className: "cedros-data__subtitle", children: "Loading the current schema requires `data:ops:write`." })), !canWriteSchema && (_jsx("p", { className: "cedros-data__subtitle", children: "Applying schema changes requires `data:schema:write`." }))] }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", onClick: () => void loadCurrent(), disabled: loading || !canLoadCurrentSchema, title: !canLoadCurrentSchema ? "Requires data:ops:write" : undefined, children: "Load Current" }), _jsx(AdminButton, { variant: "secondary", onClick: resetProposal, disabled: loading, children: "Reset Proposal" }), _jsx(AdminButton, { variant: "primary", onClick: () => void applySchema(), disabled: loading || !canWriteSchema, title: !canWriteSchema ? "Requires data:schema:write" : undefined, children: "Apply Schema" })] })] }), _jsxs("div", { className: "cedros-data-grid cedros-data-grid--two", children: [_jsx(Card, { title: "Current Schema", subtitle: "Loaded from latest site export.", children: _jsx(JsonEditor, { label: "Current", value: JSON.stringify(currentSchema, null, 2), readOnly: true }) }), _jsx(Card, { title: "Proposed Schema", subtitle: "Full schema JSON (types, tables, constraints, indexes).", children: _jsx(JsonEditor, { label: "Proposal", value: proposalEditor, onChange: (event) => setProposalEditor(event.target.value), disabled: !canWriteSchema }) })] }), _jsxs(Card, { title: "Diff Preview", subtitle: "Server blocks breaking changes automatically.", children: [_jsx(DiffColumn, { title: "Additive Changes", items: diff.additive }), _jsx(DiffColumn, { title: "Breaking Changes", items: diff.breaking, isBreaking: true }), _jsx(DiffColumn, { title: "Validation Warnings", items: diff.warnings, isBreaking: true })] }), latestReport && (_jsx(Card, { title: "Last Apply Report", subtitle: `Version ${latestReport.version} • ${latestReport.applied ? "applied" : "blocked"}`, children: _jsx(JsonEditor, { label: "Report", value: JSON.stringify(latestReport, null, 2), readOnly: true }) })), status && _jsx(StatusNotice, { tone: tone, message: status })] }));
+}
+function DiffColumn({ title, items, isBreaking = false }) {
+    return (_jsxs("div", { style: { display: "grid", gap: "0.4rem" }, children: [_jsx("strong", { children: title }), items.length === 0 && _jsx("span", { className: "cedros-data-empty", children: "None." }), items.map((item) => (_jsxs("span", { className: "cedros-data-key", style: { color: isBreaking ? "var(--cd-error)" : undefined }, children: ["\u2022 ", item] }, `${title}-${item}`)))] }));
+}
+function normalizeSchemaDefinition(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        return EMPTY_SCHEMA;
+    }
+    const value = raw;
+    const types = Array.isArray(value.types)
+        ? value.types.filter(isRecord).map((entry) => ({ ...entry }))
+        : [];
+    const tables = Array.isArray(value.tables)
+        ? value.tables.filter(isRecord).map((entry) => ({ ...entry }))
+        : [];
+    return { types, tables };
+}
+function summarizeDiff(currentSchema, proposalSchema) {
+    const currentTypes = new Set(currentSchema.types.map((item) => typeKey(item)));
+    const proposalTypes = new Set(proposalSchema.types.map((item) => typeKey(item)));
+    const currentTables = new Set(currentSchema.tables.map((item) => tableName(item)));
+    const proposalTables = new Set(proposalSchema.tables.map((item) => tableName(item)));
+    const additive = [];
+    const breaking = [];
+    const warnings = [];
+    for (const value of proposalTypes) {
+        if (!currentTypes.has(value)) {
+            additive.push(`Add type ${value}`);
+        }
+    }
+    for (const value of currentTypes) {
+        if (!proposalTypes.has(value)) {
+            breaking.push(`Remove type ${value}`);
+        }
+    }
+    for (const value of proposalTables) {
+        if (!currentTables.has(value)) {
+            additive.push(`Add table ${value}`);
+        }
+    }
+    for (const value of currentTables) {
+        if (!proposalTables.has(value)) {
+            breaking.push(`Remove table ${value}`);
+        }
+    }
+    if (proposalSchema.types.length === 0 && proposalSchema.tables.length === 0) {
+        warnings.push("Proposal contains no types or tables.");
+    }
+    return { additive, breaking, warnings };
+}
+function typeKey(type) {
+    const kind = typeof type.kind === "string" ? type.kind : "type";
+    const name = typeof type.name === "string" ? type.name : "unnamed";
+    return `${kind}:${name}`;
+}
+function tableName(table) {
+    return typeof table.name === "string" ? table.name : "unnamed";
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}

package/dist/admin/sections/SiteSettingsSection.d.ts

@@ -0,0 +1,12 @@
+import type { AdminSectionProps } from "../types.js";
+interface SiteSettingsRecord {
+    siteTitle: string;
+    siteDescription: string;
+    locale: string;
+    timezone: string;
+}
+type SiteSettingsPayload = Record<string, unknown>;
+export default function SiteSettingsSection({ pluginContext }: AdminSectionProps): React.JSX.Element;
+export declare function normalizeSettingsPayload(value: unknown): SiteSettingsPayload;
+export declare function mergeSettingsRecordIntoPayload(payload: SiteSettingsPayload, settings: SiteSettingsRecord): SiteSettingsPayload;
+export {};

package/dist/admin/sections/SiteSettingsSection.js

@@ -0,0 +1,122 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from "react";
+import { requestJson } from "../api.js";
+import { AdminButton, Card, JsonEditor, StatusNotice, TextInput } from "../components.js";
+const DEFAULT_SETTINGS = {
+    siteTitle: "New Site",
+    siteDescription: "",
+    locale: "en-US",
+    timezone: "UTC"
+};
+export default function SiteSettingsSection({ pluginContext }) {
+    const canWriteSettings = pluginContext.hasPermission("data:settings:write");
+    const [settingsPayload, setSettingsPayload] = useState(normalizeSettingsPayload(DEFAULT_SETTINGS));
+    const [settings, setSettings] = useState(DEFAULT_SETTINGS);
+    const [rawEditor, setRawEditor] = useState(JSON.stringify(DEFAULT_SETTINGS, null, 2));
+    const [status, setStatus] = useState("");
+    const [tone, setTone] = useState("neutral");
+    const [loading, setLoading] = useState(false);
+    const load = useCallback(async () => {
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            const entries = await requestJson(pluginContext, "/entries/query", {
+                method: "POST",
+                body: {
+                    collection_name: "site_settings",
+                    entry_keys: ["global"],
+                    contains: null,
+                    limit: 1,
+                    offset: 0
+                }
+            });
+            const payload = normalizeSettingsPayload(entries[0]?.payload ?? DEFAULT_SETTINGS);
+            const typed = toSettingsRecord(payload);
+            setSettingsPayload(payload);
+            setSettings(typed);
+            setRawEditor(JSON.stringify(payload, null, 2));
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [pluginContext]);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const save = useCallback(async (nextPayload) => {
+        if (!canWriteSettings) {
+            setStatus("You do not have permission to edit site settings.");
+            setTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            await requestJson(pluginContext, "/entries/upsert", {
+                method: "POST",
+                body: {
+                    collection_name: "site_settings",
+                    entry_key: "global",
+                    payload: nextPayload
+                }
+            });
+            setSettingsPayload(nextPayload);
+            setSettings(toSettingsRecord(nextPayload));
+            setRawEditor(JSON.stringify(nextPayload, null, 2));
+            setStatus("Site settings saved.");
+            setTone("success");
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [canWriteSettings, pluginContext]);
+    const saveForm = useCallback(async () => {
+        await save(mergeSettingsRecordIntoPayload(settingsPayload, settings));
+    }, [save, settings, settingsPayload]);
+    const applyRaw = useCallback(async () => {
+        let parsed;
+        try {
+            parsed = JSON.parse(rawEditor);
+        }
+        catch (error) {
+            setStatus(`Invalid JSON: ${error.message}`);
+            setTone("error");
+            return;
+        }
+        await save(normalizeSettingsPayload(parsed));
+    }, [rawEditor, save]);
+    return (_jsxs("div", { className: "cedros-data", children: [_jsxs("header", { className: "cedros-data__header", children: [_jsxs("div", { children: [_jsx("h2", { className: "cedros-data__title", children: "Site Settings" }), _jsx("p", { className: "cedros-data__subtitle", children: "Configure the global metadata for this site." }), !canWriteSettings && (_jsx("p", { className: "cedros-data__subtitle", children: "Read-only mode. Missing `data:settings:write` permission." }))] }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", onClick: () => void load(), disabled: loading, children: "Refresh" }), _jsx(AdminButton, { variant: "primary", onClick: () => void saveForm(), disabled: loading || !canWriteSettings, title: !canWriteSettings ? "Requires data:settings:write" : undefined, children: "Save Form" }), _jsx(AdminButton, { variant: "secondary", onClick: () => void applyRaw(), disabled: loading || !canWriteSettings, title: !canWriteSettings ? "Requires data:settings:write" : undefined, children: "Save JSON" })] })] }), _jsxs("div", { className: "cedros-data-grid cedros-data-grid--two", children: [_jsxs(Card, { title: "Global Site Fields", subtitle: "These values back site_settings/global.", children: [_jsx(TextInput, { label: "Site Title", value: settings.siteTitle, onChange: (event) => setSettings((previous) => ({ ...previous, siteTitle: event.target.value })), placeholder: "Cedros Docs", disabled: !canWriteSettings }), _jsx(TextInput, { label: "Site Description", value: settings.siteDescription, onChange: (event) => setSettings((previous) => ({ ...previous, siteDescription: event.target.value })), placeholder: "Developer docs and guides", disabled: !canWriteSettings }), _jsx(TextInput, { label: "Locale", value: settings.locale, onChange: (event) => setSettings((previous) => ({ ...previous, locale: event.target.value })), placeholder: "en-US", disabled: !canWriteSettings }), _jsx(TextInput, { label: "Timezone", value: settings.timezone, onChange: (event) => setSettings((previous) => ({ ...previous, timezone: event.target.value })), placeholder: "America/Los_Angeles", disabled: !canWriteSettings })] }), _jsx(Card, { title: "Settings JSON", subtitle: "Advanced editor for all site settings fields.", children: _jsx(JsonEditor, { label: "site_settings/global", value: rawEditor, onChange: (event) => setRawEditor(event.target.value), disabled: !canWriteSettings }) })] }), status && _jsx(StatusNotice, { tone: tone, message: status })] }));
+}
+export function normalizeSettingsPayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return { ...DEFAULT_SETTINGS };
+    }
+    return { ...value };
+}
+export function mergeSettingsRecordIntoPayload(payload, settings) {
+    return {
+        ...normalizeSettingsPayload(payload),
+        ...settings
+    };
+}
+function toSettingsRecord(value) {
+    const source = normalizeSettingsPayload(value);
+    return {
+        siteTitle: typeof source.siteTitle === "string" && source.siteTitle.trim().length > 0
+            ? source.siteTitle
+            : DEFAULT_SETTINGS.siteTitle,
+        siteDescription: typeof source.siteDescription === "string" ? source.siteDescription : DEFAULT_SETTINGS.siteDescription,
+        locale: typeof source.locale === "string" && source.locale ? source.locale : DEFAULT_SETTINGS.locale,
+        timezone: typeof source.timezone === "string" && source.timezone ? source.timezone : DEFAULT_SETTINGS.timezone
+    };
+}

package/dist/admin/sections/TippingSection.d.ts

@@ -0,0 +1,2 @@
+import type { AdminSectionProps } from "../types.js";
+export default function TippingSection({ pluginContext }: AdminSectionProps): React.JSX.Element;

package/dist/admin/sections/TippingSection.js

@@ -0,0 +1,178 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useState } from "react";
+import { requestJson } from "../api.js";
+import { AdminButton, Card, JsonEditor, StatusNotice, TextInput } from "../components.js";
+const KNOWN_CURRENCIES = [
+    { symbol: "SOL", enabled: true },
+    { symbol: "USDC", mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", enabled: false },
+];
+const DEFAULT_CONFIG = {
+    enabled: false,
+    recipient: "",
+    label: "Leave a tip",
+    description: "",
+    allowPerPostRecipient: false,
+    currencies: KNOWN_CURRENCIES,
+};
+export default function TippingSection({ pluginContext }) {
+    const canWrite = pluginContext.hasPermission("data:settings:write");
+    const [payload, setPayload] = useState({ ...DEFAULT_CONFIG });
+    const [config, setConfig] = useState(DEFAULT_CONFIG);
+    const [rawEditor, setRawEditor] = useState(JSON.stringify(DEFAULT_CONFIG, null, 2));
+    const [status, setStatus] = useState("");
+    const [tone, setTone] = useState("neutral");
+    const [loading, setLoading] = useState(false);
+    const load = useCallback(async () => {
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            const entries = await requestJson(pluginContext, "/entries/query", {
+                method: "POST",
+                body: {
+                    collection_name: "site_settings",
+                    entry_keys: ["tipping"],
+                    contains: null,
+                    limit: 1,
+                    offset: 0
+                }
+            });
+            const raw = normalizePayload(entries[0]?.payload ?? DEFAULT_CONFIG);
+            const typed = toConfig(raw);
+            setPayload(raw);
+            setConfig(typed);
+            setRawEditor(JSON.stringify(raw, null, 2));
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [pluginContext]);
+    useEffect(() => {
+        void load();
+    }, [load]);
+    const save = useCallback(async (nextPayload) => {
+        if (!canWrite) {
+            setStatus("You do not have permission to edit tipping settings.");
+            setTone("error");
+            return;
+        }
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            await requestJson(pluginContext, "/entries/upsert", {
+                method: "POST",
+                body: {
+                    collection_name: "site_settings",
+                    entry_key: "tipping",
+                    payload: nextPayload
+                }
+            });
+            setPayload(nextPayload);
+            setConfig(toConfig(nextPayload));
+            setRawEditor(JSON.stringify(nextPayload, null, 2));
+            setStatus("Tipping settings saved.");
+            setTone("success");
+        }
+        catch (error) {
+            setStatus(error.message);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [canWrite, pluginContext]);
+    const saveForm = useCallback(async () => {
+        await save(mergeConfigIntoPayload(payload, config));
+    }, [save, config, payload]);
+    const applyRaw = useCallback(async () => {
+        let parsed;
+        try {
+            parsed = JSON.parse(rawEditor);
+        }
+        catch (error) {
+            setStatus(`Invalid JSON: ${error.message}`);
+            setTone("error");
+            return;
+        }
+        await save(normalizePayload(parsed));
+    }, [rawEditor, save]);
+    const handleEnsureAta = useCallback(async () => {
+        const splCurrencies = config.currencies.filter((c) => c.mint && c.enabled);
+        if (!config.recipient || splCurrencies.length === 0)
+            return;
+        setLoading(true);
+        setStatus("");
+        setTone("neutral");
+        try {
+            const { ensureRecipientAta } = await import("../../site-templates/solanaAtaSetup.js");
+            const results = [];
+            for (const cur of splCurrencies) {
+                const ata = await ensureRecipientAta(config.recipient, cur.mint);
+                results.push(`${cur.symbol}: ${ata}`);
+            }
+            setStatus(`ATAs ready: ${results.join(", ")}`);
+            setTone("success");
+        }
+        catch (error) {
+            setStatus(`ATA creation failed: ${error.message}`);
+            setTone("error");
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [config.recipient, config.currencies]);
+    return (_jsxs("div", { className: "cedros-data", children: [_jsxs("header", { className: "cedros-data__header", children: [_jsxs("div", { children: [_jsx("h2", { className: "cedros-data__title", children: "Tipping" }), _jsx("p", { className: "cedros-data__subtitle", children: "Configure tipping widget for your site." }), !canWrite && (_jsx("p", { className: "cedros-data__subtitle", children: "Read-only mode. Missing `data:settings:write` permission." }))] }), _jsxs("div", { className: "cedros-data-actions", children: [_jsx(AdminButton, { variant: "secondary", onClick: () => void load(), disabled: loading, children: "Refresh" }), _jsx(AdminButton, { variant: "primary", onClick: () => void saveForm(), disabled: loading || !canWrite, title: !canWrite ? "Requires data:settings:write" : undefined, children: "Save Form" }), _jsx(AdminButton, { variant: "secondary", onClick: () => void applyRaw(), disabled: loading || !canWrite, title: !canWrite ? "Requires data:settings:write" : undefined, children: "Save JSON" })] })] }), _jsxs("div", { className: "cedros-data-grid cedros-data-grid--two", children: [_jsxs(Card, { title: "Tipping Settings", subtitle: "Basic tipping configuration.", children: [_jsxs("label", { className: "cedros-data-checkbox-row", children: [_jsx("input", { type: "checkbox", checked: config.enabled, onChange: (e) => setConfig((prev) => ({ ...prev, enabled: e.target.checked })), disabled: !canWrite }), "Enabled"] }), _jsx(TextInput, { label: "Recipient", value: config.recipient, onChange: (e) => setConfig((prev) => ({ ...prev, recipient: e.target.value })), placeholder: "Wallet address or identifier", disabled: !canWrite }), _jsx(TextInput, { label: "Label", value: config.label, onChange: (e) => setConfig((prev) => ({ ...prev, label: e.target.value })), placeholder: "Leave a tip", disabled: !canWrite }), _jsx(TextInput, { label: "Description", value: config.description, onChange: (e) => setConfig((prev) => ({ ...prev, description: e.target.value })), placeholder: "Optional description", disabled: !canWrite }), _jsxs("label", { className: "cedros-data-checkbox-row", children: [_jsx("input", { type: "checkbox", checked: config.allowPerPostRecipient, onChange: (e) => setConfig((prev) => ({ ...prev, allowPerPostRecipient: e.target.checked })), disabled: !canWrite }), "Allow per-post recipient"] }), _jsx("p", { className: "cedros-data__subtitle", style: { margin: 0 }, children: "When enabled, individual blog posts can override the site-wide tip recipient." }), _jsx("h4", { style: { margin: "1rem 0 0.5rem" }, children: "Currencies" }), config.currencies.map((cur) => (_jsxs("label", { className: "cedros-data-checkbox-row", children: [_jsx("input", { type: "checkbox", checked: cur.enabled, disabled: !canWrite || cur.symbol === "SOL", onChange: (e) => {
+                                            setConfig((prev) => ({
+                                                ...prev,
+                                                currencies: prev.currencies.map((c) => c.symbol === cur.symbol ? { ...c, enabled: e.target.checked } : c),
+                                            }));
+                                        } }), cur.symbol, cur.symbol === "SOL" ? " (always enabled)" : ""] }, cur.symbol))), config.currencies.some((c) => c.mint && c.enabled) && (_jsx(AdminButton, { variant: "secondary", disabled: !config.recipient || loading, onClick: () => void handleEnsureAta(), title: !config.recipient ? "Set recipient address first" : undefined, children: "Ensure Recipient ATA" }))] }), _jsx(Card, { title: "Tipping JSON", subtitle: "Advanced editor for currencies, presets, and more.", children: _jsx(JsonEditor, { label: "site_settings/tipping", value: rawEditor, onChange: (e) => setRawEditor(e.target.value), disabled: !canWrite }) })] }), status && _jsx(StatusNotice, { tone: tone, message: status })] }));
+}
+function normalizePayload(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return { ...DEFAULT_CONFIG };
+    }
+    return { ...value };
+}
+function mergeConfigIntoPayload(payload, config) {
+    return { ...normalizePayload(payload), ...config };
+}
+function parseCurrencies(raw) {
+    if (!Array.isArray(raw))
+        return KNOWN_CURRENCIES;
+    const parsed = raw
+        .filter((c) => !!c && typeof c === "object")
+        .map((c) => ({
+        symbol: typeof c.symbol === "string" ? c.symbol : "?",
+        mint: typeof c.mint === "string" ? c.mint : undefined,
+        enabled: typeof c.enabled === "boolean" ? c.enabled : false,
+    }));
+    // Ensure SOL is always present and enabled
+    if (!parsed.some((c) => c.symbol === "SOL")) {
+        parsed.unshift({ symbol: "SOL", enabled: true });
+    }
+    else {
+        const sol = parsed.find((c) => c.symbol === "SOL");
+        if (sol)
+            sol.enabled = true;
+    }
+    return parsed;
+}
+function toConfig(value) {
+    const source = normalizePayload(value);
+    return {
+        enabled: typeof source.enabled === "boolean" ? source.enabled : DEFAULT_CONFIG.enabled,
+        recipient: typeof source.recipient === "string" ? source.recipient : DEFAULT_CONFIG.recipient,
+        label: typeof source.label === "string" && source.label ? source.label : DEFAULT_CONFIG.label,
+        description: typeof source.description === "string" ? source.description : DEFAULT_CONFIG.description,
+        allowPerPostRecipient: typeof source.allowPerPostRecipient === "boolean"
+            ? source.allowPerPostRecipient
+            : DEFAULT_CONFIG.allowPerPostRecipient,
+        currencies: parseCurrencies(source.currencies),
+    };
+}