@cedros/data-react 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,24 @@
+# Changelog
+
+## Unreleased
+
+### Added
+- `MarkdownContent` renderer based on `react-markdown` + `remark-gfm` + `rehype-slug`.
+- `bodyMarkdown` support in:
+  - `BlogPostTemplate`
+  - `DocArticleTemplate`
+  - `LegalPageTemplate`
+- `allowUnsafeHtmlFallback` opt-in for legacy raw HTML rendering.
+- GitBook-style docs navigation helpers and layout support (`buildDocsSidebarSections`, `withActiveDocsSidebar`).
+- End-to-end example for loading markdown from `cedros-data` and rendering docs templates.
+
+### Changed
+- `bodyHtml` is no longer the default rendering path for article/legal templates.
+- Raw HTML now requires explicit `allowUnsafeHtmlFallback={true}`.
+
+### Migration Notes
+- Before:
+  - `bodyHtml` as primary content input.
+- After:
+  - use `bodyMarkdown` as primary input.
+  - keep `bodyHtml` only for compatibility and set `allowUnsafeHtmlFallback={true}` if absolutely required.

package/README.md

@@ -0,0 +1,177 @@
+# @cedros/data-react
+
+`@cedros/data-react` is the frontend companion package for `cedros-data`.
+
+It provides:
+- a cedros-login `AdminShell` plugin (`cedrosDataPlugin`)
+- reusable admin primitives/components
+- reusable site layout components
+- page templates for core/content/legal routes
+- GitBook-style docs rendering with markdown support
+
+## Install
+
+```bash
+cd ui
+npm install
+```
+
+## Build and test
+
+```bash
+npm run check
+npm run build
+npm test
+npm run test:packaged
+```
+
+Packaging smoke:
+- `npm pack --dry-run` now runs `prepack`, which rebuilds `dist/` and verifies every exported JS/CSS/types file before the tarball is assembled
+
+## Package exports
+
+- `@cedros/data-react`
+  - `defaultPageTemplates`
+  - `DefaultPageKey`, `PageTemplateContract`
+  - re-exports admin + site-template modules
+- `@cedros/data-react/admin`
+  - `cedrosDataPlugin`
+  - section IDs/groups/types
+  - admin components/primitives
+- `@cedros/data-react/site-templates`
+  - site shell/layout components
+  - page templates
+  - routing/content helpers
+- `@cedros/data-react/admin/styles.css`
+- `@cedros/data-react/site-templates/styles.css`
+
+Runtime packaging note:
+- the published JS entrypoints are side-effect-free so they stay importable in Node/SSR
+- import `@cedros/data-react/admin/styles.css` and/or `@cedros/data-react/site-templates/styles.css` explicitly in browser apps that need the packaged styles
+
+Publish surface:
+- npm tarballs intentionally include only `dist/`, `README.md`, and `CHANGELOG.md`
+- source files, tests, examples, and local task notes stay out of the published package
+
+## AdminShell integration
+
+```tsx
+import { AdminShell, cedrosLoginPlugin } from "@cedros/login-react";
+import { cedrosDataPlugin } from "@cedros/data-react/admin";
+
+<AdminShell
+  plugins={[cedrosLoginPlugin, cedrosDataPlugin]}
+  hostContext={{
+    cedrosLogin: {
+      user,
+      getAccessToken,
+      serverUrl: "http://localhost:8080"
+    },
+    org: { orgId: "11111111-1111-1111-1111-111111111111", role: "owner", permissions: [] },
+    custom: {
+      cedrosData: {
+        serverUrl: "http://localhost:8080"
+      }
+    }
+  }}
+/>;
+```
+
+Plugin context behavior:
+- resolves `serverUrl` from `custom.cedrosData.serverUrl` or `cedrosLogin.serverUrl`
+- forwards bearer token from `cedrosLogin.getAccessToken()`
+- forwards `x-cedros-org-id` when `hostContext.org.orgId` is present
+
+## Admin sections
+
+Content:
+- `pages`
+- `navigation`
+- `site-settings`
+
+Data model:
+- `collections`
+- `schema-designer`
+- `contract-verify`
+- `custom-data`
+
+Operations:
+- `data-ops`
+- `history`
+
+## Styling and dark mode
+
+- Admin UIs use tokenized variables aligned with cedros-login/cedros-pay conventions.
+- Dark mode responds to both:
+  - `.cedros-dark`
+  - `.cedros-admin--dark`
+- Direct import option:
+
+```ts
+import "@cedros/data-react/admin/styles.css";
+```
+
+## Site templates and components
+
+Layouts/navigation:
+- `SiteLayout`
+- `TopNav`
+- `SiteFooter`
+- `DashboardShell`
+
+Core page templates:
+- `HomePageTemplate`
+- `ContactPageTemplate`
+- `LegalPageTemplate`
+- `NotFoundTemplate`
+- `DashboardOverviewTemplate`
+
+Blog templates:
+- `BlogIndexTemplate`
+- `BlogPostTemplate`
+
+Docs templates:
+- `DocsIndexTemplate`
+- `DocArticleTemplate` (GitBook-style left nav + right TOC)
+
+Content rendering and helpers:
+- `MarkdownContent`
+- `Breadcrumbs`
+- `ContentPagination`
+- `withActiveRouteState`
+- `buildDocsSidebarSections`
+- `withActiveDocsSidebar`
+- `prepareBlogIndex`
+- `prepareDocsIndex`
+- `collectFilterValues`
+- `buildContentListHref`
+
+## Markdown and HTML behavior
+
+Docs/blog templates default to `bodyMarkdown`.
+
+`bodyHtml` remains compatibility fallback and is only rendered when:
+- `allowUnsafeHtmlFallback={true}`
+
+This keeps markdown as the safe default and avoids unsafe HTML rendering by default.
+
+## Default page contract
+
+The package exports the default page template contract used by server bootstrap:
+- `home`
+- `about`
+- `contact`
+- `docs`
+- `blog`
+- `privacy-policy`
+- `terms-of-service`
+- `not-found`
+
+## Example
+
+End-to-end markdown integration example:
+- `examples/cedros-data-markdown-e2e.tsx`
+- the example reads page records from `GET /admin/pages` and uses each record's `entry_key`
+
+See also:
+- `CHANGELOG.md`

package/dist/admin/api.d.ts

@@ -0,0 +1,19 @@
+import type { PluginContext } from "./types.js";
+interface RequestOptions {
+    method?: string;
+    body?: unknown;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export declare function requestJson<T>(pluginContext: PluginContext, path: string, options?: RequestOptions): Promise<T>;
+export interface LatestRequest {
+    signal: AbortSignal;
+    isCurrent: () => boolean;
+}
+export interface LatestRequestController {
+    begin: () => LatestRequest;
+    cancel: () => void;
+}
+export declare function createLatestRequestController(): LatestRequestController;
+export declare function uploadFile<T>(pluginContext: PluginContext, path: string, formData: FormData): Promise<T>;
+export {};

package/dist/admin/api.js

@@ -0,0 +1,108 @@
+const DEFAULT_REQUEST_TIMEOUT_MS = 15_000;
+export async function requestJson(pluginContext, path, options = {}) {
+    const token = pluginContext.getAccessToken();
+    const headers = {
+        "Content-Type": "application/json"
+    };
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    if (pluginContext.orgId) {
+        headers["x-cedros-org-id"] = pluginContext.orgId;
+    }
+    const baseUrl = pluginContext.serverUrl.replace(/\/+$/, "");
+    const requestPath = path.startsWith("/") ? path : `/${path}`;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    const controller = new AbortController();
+    const onAbort = () => controller.abort();
+    let timedOut = false;
+    let timeoutId;
+    if (options.signal) {
+        if (options.signal.aborted) {
+            controller.abort();
+        }
+        else {
+            options.signal.addEventListener("abort", onAbort, { once: true });
+        }
+    }
+    if (timeoutMs > 0) {
+        timeoutId = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+    }
+    try {
+        const response = await fetch(`${baseUrl}${requestPath}`, {
+            method: options.method ?? "GET",
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal: controller.signal
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(text || `Request failed (${response.status})`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        if (timedOut && isAbortError(error)) {
+            throw new Error(`Request timed out after ${timeoutMs}ms`);
+        }
+        throw error;
+    }
+    finally {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+        options.signal?.removeEventListener("abort", onAbort);
+    }
+}
+export function createLatestRequestController() {
+    let currentToken = 0;
+    let currentController = null;
+    return {
+        begin() {
+            currentToken += 1;
+            currentController?.abort();
+            const controller = new AbortController();
+            currentController = controller;
+            const requestToken = currentToken;
+            return {
+                signal: controller.signal,
+                isCurrent: () => currentController === controller &&
+                    currentToken === requestToken &&
+                    !controller.signal.aborted
+            };
+        },
+        cancel() {
+            currentToken += 1;
+            currentController?.abort();
+            currentController = null;
+        }
+    };
+}
+export async function uploadFile(pluginContext, path, formData) {
+    const token = pluginContext.getAccessToken();
+    const headers = {};
+    if (token) {
+        headers.Authorization = `Bearer ${token}`;
+    }
+    if (pluginContext.orgId) {
+        headers["x-cedros-org-id"] = pluginContext.orgId;
+    }
+    const baseUrl = pluginContext.serverUrl.replace(/\/+$/, "");
+    const requestPath = path.startsWith("/") ? path : `/${path}`;
+    const response = await fetch(`${baseUrl}${requestPath}`, {
+        method: "POST",
+        headers,
+        body: formData
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(text || `Upload failed (${response.status})`);
+    }
+    return (await response.json());
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}

package/dist/admin/components.d.ts

@@ -0,0 +1,36 @@
+import type * as React from "react";
+import type { ButtonHTMLAttributes, InputHTMLAttributes, ReactNode, SelectHTMLAttributes, TextareaHTMLAttributes } from "react";
+type ButtonVariant = "primary" | "secondary" | "ghost" | "danger";
+type ButtonSize = "sm" | "md";
+interface AdminButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+}
+export declare function AdminButton({ className, variant, size, ...rest }: AdminButtonProps): React.JSX.Element;
+interface CardProps {
+    title?: string;
+    subtitle?: string;
+    actions?: ReactNode;
+    children: ReactNode;
+}
+export declare function Card({ title, subtitle, actions, children }: CardProps): React.JSX.Element;
+interface TextInputProps extends InputHTMLAttributes<HTMLInputElement> {
+    label?: string;
+}
+export declare function TextInput({ label, className, ...rest }: TextInputProps): React.JSX.Element;
+interface SelectInputProps extends SelectHTMLAttributes<HTMLSelectElement> {
+    label?: string;
+    children: ReactNode;
+}
+export declare function SelectInput({ label, className, children, ...rest }: SelectInputProps): React.JSX.Element;
+interface JsonEditorProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    label?: string;
+}
+export declare function JsonEditor({ label, className, ...rest }: JsonEditorProps): React.JSX.Element;
+type StatusTone = "neutral" | "success" | "error";
+interface StatusNoticeProps {
+    tone: StatusTone;
+    message: string;
+}
+export declare function StatusNotice({ tone, message }: StatusNoticeProps): React.JSX.Element;
+export {};

package/dist/admin/components.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+function cx(...parts) {
+    return parts.filter(Boolean).join(" ");
+}
+export function AdminButton({ className, variant = "secondary", size = "md", ...rest }) {
+    return (_jsx("button", { className: cx("cedros-data-btn", `cedros-data-btn--${variant}`, size === "sm" ? "cedros-data-btn--sm" : undefined, className), ...rest }));
+}
+export function Card({ title, subtitle, actions, children }) {
+    return (_jsxs("section", { className: "cedros-data-card", children: [(title || subtitle || actions) && (_jsxs("header", { className: "cedros-data-card__header", children: [_jsxs("div", { children: [title && _jsx("h3", { className: "cedros-data-card__title", children: title }), subtitle && _jsx("p", { className: "cedros-data-card__subtitle", children: subtitle })] }), actions] })), _jsx("div", { className: "cedros-data-card__body", children: children })] }));
+}
+export function TextInput({ label, className, ...rest }) {
+    return (_jsxs("label", { className: "cedros-data-field", children: [label && _jsx("span", { className: "cedros-data-label", children: label }), _jsx("input", { className: cx("cedros-data-input", className), ...rest })] }));
+}
+export function SelectInput({ label, className, children, ...rest }) {
+    return (_jsxs("label", { className: "cedros-data-field", children: [label && _jsx("span", { className: "cedros-data-label", children: label }), _jsx("select", { className: cx("cedros-data-select", className), ...rest, children: children })] }));
+}
+export function JsonEditor({ label, className, ...rest }) {
+    return (_jsxs("label", { className: "cedros-data-field", children: [label && _jsx("span", { className: "cedros-data-label", children: label }), _jsx("textarea", { className: cx("cedros-data-textarea", className), ...rest })] }));
+}
+export function StatusNotice({ tone, message }) {
+    return _jsx("div", { className: cx("cedros-data-status", `cedros-data-status--${tone}`), children: message });
+}

package/dist/admin/history.d.ts

@@ -0,0 +1,17 @@
+export type DataOperation = "bootstrap" | "export" | "import";
+export type DataOperationStatus = "success" | "error";
+export interface DataOpsHistoryRecord {
+    id: string;
+    operation: DataOperation;
+    status: DataOperationStatus;
+    message: string;
+    createdAt: string;
+    artifact?: string;
+}
+export interface DataOpsHistoryMutationResult {
+    records: DataOpsHistoryRecord[];
+    warning?: string;
+}
+export declare function readDataOpsHistory(): DataOpsHistoryRecord[];
+export declare function appendDataOpsHistory(record: Omit<DataOpsHistoryRecord, "id" | "createdAt">): DataOpsHistoryMutationResult;
+export declare function clearDataOpsHistory(): DataOpsHistoryMutationResult;

package/dist/admin/history.js

@@ -0,0 +1,103 @@
+const STORAGE_KEY = "cedros-data:data-ops-history";
+const MAX_RECORDS = 100;
+const MAX_ARTIFACT_LENGTH = 2_000;
+const STORAGE_WARNING = "Local history could not be saved in browser storage. The operation still completed.";
+export function readDataOpsHistory() {
+    return readAllRecords();
+}
+export function appendDataOpsHistory(record) {
+    const entry = {
+        id: `${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
+        createdAt: new Date().toISOString(),
+        ...record
+    };
+    entry.artifact = sanitizeArtifact(entry.artifact);
+    const records = [entry, ...readAllRecords()].slice(0, MAX_RECORDS);
+    return {
+        records,
+        warning: writeAllRecords(records)
+    };
+}
+export function clearDataOpsHistory() {
+    const records = [];
+    return {
+        records,
+        warning: writeAllRecords(records)
+    };
+}
+function readAllRecords() {
+    const storage = resolveLocalStorage();
+    if (!storage) {
+        return [];
+    }
+    try {
+        const raw = storage.getItem(STORAGE_KEY);
+        if (!raw) {
+            return [];
+        }
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed)) {
+            return [];
+        }
+        const records = parsed.filter(isHistoryRecord).map(sanitizeHistoryRecord);
+        void writeAllRecords(records);
+        return records;
+    }
+    catch (_error) {
+        return [];
+    }
+}
+function writeAllRecords(records) {
+    const storage = resolveLocalStorage();
+    if (!storage) {
+        return STORAGE_WARNING;
+    }
+    try {
+        storage.setItem(STORAGE_KEY, JSON.stringify(records));
+        return undefined;
+    }
+    catch (_error) {
+        return STORAGE_WARNING;
+    }
+}
+function resolveLocalStorage() {
+    if (typeof window === "undefined") {
+        return null;
+    }
+    try {
+        return window.localStorage;
+    }
+    catch (_error) {
+        return null;
+    }
+}
+function isHistoryRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const item = value;
+    return (typeof item.id === "string" &&
+        typeof item.operation === "string" &&
+        typeof item.status === "string" &&
+        typeof item.message === "string" &&
+        typeof item.createdAt === "string" &&
+        (item.artifact === undefined || typeof item.artifact === "string"));
+}
+function sanitizeHistoryRecord(record) {
+    return {
+        ...record,
+        artifact: sanitizeArtifact(record.artifact)
+    };
+}
+function sanitizeArtifact(artifact) {
+    if (!artifact) {
+        return undefined;
+    }
+    if (artifact.length <= MAX_ARTIFACT_LENGTH) {
+        return artifact;
+    }
+    return JSON.stringify({
+        note: "Legacy payload snapshot omitted from local history.",
+        originalLength: artifact.length
+    }, null, 2);
+}

package/dist/admin/icons.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+export declare const Icons: {
+    pages: ReactNode;
+    navigation: ReactNode;
+    siteSettings: ReactNode;
+    media: ReactNode;
+    collections: ReactNode;
+    schemaDesigner: ReactNode;
+    contractVerify: ReactNode;
+    customData: ReactNode;
+    dataOps: ReactNode;
+    history: ReactNode;
+    tipping: ReactNode;
+    monetization: ReactNode;
+};

package/dist/admin/icons.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+function icon(path) {
+    return (_jsx("svg", { width: "16", height: "16", viewBox: "0 0 24 24", fill: "none", "aria-hidden": "true", children: _jsx("path", { d: path, stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) }));
+}
+export const Icons = {
+    pages: icon("M4 5h16M4 12h16M4 19h16"),
+    navigation: icon("M3 6h18M3 12h10M3 18h14"),
+    siteSettings: icon("M12 3v4M12 17v4M3 12h4M17 12h4M5.6 5.6l2.8 2.8M15.6 15.6l2.8 2.8M18.4 5.6l-2.8 2.8M8.4 15.6l-2.8 2.8"),
+    media: icon("M4 5a1 1 0 011-1h14a1 1 0 011 1v14a1 1 0 01-1 1H5a1 1 0 01-1-1V5zM8.5 10a1.5 1.5 0 100-3 1.5 1.5 0 000 3zM20 15l-5-5L6 20"),
+    collections: icon("M5 4h14v4H5zM5 10h14v4H5zM5 16h14v4H5z"),
+    schemaDesigner: icon("M4 7h16M4 12h16M4 17h10M17 17h3"),
+    contractVerify: icon("M12 3l7 3v6c0 5-3.5 8-7 9-3.5-1-7-4-7-9V6l7-3z"),
+    customData: icon("M6 4h12M4 8h16M8 12h8M8 16h8M6 20h12"),
+    dataOps: icon("M4 4h16v16H4z M8 8h8 M8 12h8 M8 16h4"),
+    history: icon("M12 8v5l3 2M20 12a8 8 0 11-2.34-5.66"),
+    tipping: icon("M12 2a7 7 0 00-7 7c0 5.25 7 13 7 13s7-7.75 7-13a7 7 0 00-7-7z"),
+    monetization: icon("M12 1v22M17 5H9.5a3.5 3.5 0 000 7h5a3.5 3.5 0 010 7H6")
+};

package/dist/admin/index.d.ts

@@ -0,0 +1,13 @@
+export type { AdminPlugin, AdminSectionConfig, AdminGroupConfig, AdminSectionProps, HostContext, PluginContext, PluginRegistry, PluginId, SectionId, QualifiedSectionId, PluginPermission } from "./types.js";
+export { cedrosDataPlugin, dataPlugin } from "./plugin.js";
+export { default as defaultDataPlugin } from "./plugin.js";
+export { CEDROS_DATA_SECTIONS, CEDROS_DATA_SECTION_IDS, CEDROS_DATA_GROUPS } from "./sectionIds.js";
+export { AdminButton, Card, TextInput, SelectInput, JsonEditor, StatusNotice } from "./components.js";
+export { DataTable, type DataTableProps, type DataTableColumn } from "./primitives/DataTable.js";
+export { Toolbar, SearchInput, FilterChips, type FilterChipItem } from "./primitives/Toolbar.js";
+export { Pagination } from "./primitives/Pagination.js";
+export { JsonCodeEditor } from "./primitives/JsonCodeEditor.js";
+export { DiffViewer, type DiffBlock } from "./primitives/DiffViewer.js";
+export { FormFieldRow, FieldTypeSelect, type FormFieldRowValue, type FieldTypeOption } from "./primitives/FormFieldRow.js";
+export { ConfirmDialog } from "./primitives/ConfirmDialog.js";
+export { ToastProvider, useToast, InlineAlert, type AlertTone } from "./primitives/alerts.js";

package/dist/admin/index.js

@@ -0,0 +1,12 @@
+export { cedrosDataPlugin, dataPlugin } from "./plugin.js";
+export { default as defaultDataPlugin } from "./plugin.js";
+export { CEDROS_DATA_SECTIONS, CEDROS_DATA_SECTION_IDS, CEDROS_DATA_GROUPS } from "./sectionIds.js";
+export { AdminButton, Card, TextInput, SelectInput, JsonEditor, StatusNotice } from "./components.js";
+export { DataTable } from "./primitives/DataTable.js";
+export { Toolbar, SearchInput, FilterChips } from "./primitives/Toolbar.js";
+export { Pagination } from "./primitives/Pagination.js";
+export { JsonCodeEditor } from "./primitives/JsonCodeEditor.js";
+export { DiffViewer } from "./primitives/DiffViewer.js";
+export { FormFieldRow, FieldTypeSelect } from "./primitives/FormFieldRow.js";
+export { ConfirmDialog } from "./primitives/ConfirmDialog.js";
+export { ToastProvider, useToast, InlineAlert } from "./primitives/alerts.js";

package/dist/admin/permissions.d.ts

@@ -0,0 +1,4 @@
+export type CedrosDataPermission = "data:pages:read" | "data:pages:write" | "data:navigation:read" | "data:navigation:write" | "data:settings:read" | "data:settings:write" | "data:collections:read" | "data:collections:write" | "data:schema:read" | "data:schema:write" | "data:contract:read" | "data:contract:write" | "data:custom:read" | "data:custom:write" | "data:media:read" | "data:media:write" | "data:history:read" | "data:ops:write" | "data:admin";
+export declare const PERMISSION_MAP: Record<CedrosDataPermission, string[]>;
+export declare function readPermissionForCollection(collectionName: string): CedrosDataPermission;
+export declare function writePermissionForCollection(collectionName: string): CedrosDataPermission;

package/dist/admin/permissions.js

@@ -0,0 +1,45 @@
+export const PERMISSION_MAP = {
+    "data:pages:read": ["owner", "admin", "data:pages:read", "data:admin"],
+    "data:pages:write": ["owner", "admin", "data:pages:write", "data:admin"],
+    "data:navigation:read": ["owner", "admin", "data:navigation:read", "data:admin"],
+    "data:navigation:write": ["owner", "admin", "data:navigation:write", "data:admin"],
+    "data:settings:read": ["owner", "admin", "data:settings:read", "data:admin"],
+    "data:settings:write": ["owner", "admin", "data:settings:write", "data:admin"],
+    "data:collections:read": ["owner", "admin", "data:collections:read", "data:admin"],
+    "data:collections:write": ["owner", "admin", "data:collections:write", "data:admin"],
+    "data:schema:read": ["owner", "admin", "data:schema:read", "data:admin"],
+    "data:schema:write": ["owner", "admin", "data:schema:write", "data:admin"],
+    "data:contract:read": ["owner", "admin", "data:contract:read", "data:admin"],
+    "data:contract:write": ["owner", "admin", "data:contract:write", "data:admin"],
+    "data:custom:read": ["owner", "admin", "data:custom:read", "data:admin"],
+    "data:custom:write": ["owner", "admin", "data:custom:write", "data:admin"],
+    "data:media:read": ["owner", "admin", "data:media:read", "data:admin"],
+    "data:media:write": ["owner", "admin", "data:media:write", "data:admin"],
+    "data:history:read": ["owner", "admin", "data:history:read", "data:admin"],
+    "data:ops:write": ["owner", "admin", "data:ops:write", "data:admin"],
+    "data:admin": ["owner", "admin", "data:admin"]
+};
+export function readPermissionForCollection(collectionName) {
+    switch (collectionName) {
+        case "pages":
+            return "data:pages:read";
+        case "navigation":
+            return "data:navigation:read";
+        case "site_settings":
+            return "data:settings:read";
+        default:
+            return "data:custom:read";
+    }
+}
+export function writePermissionForCollection(collectionName) {
+    switch (collectionName) {
+        case "pages":
+            return "data:pages:write";
+        case "navigation":
+            return "data:navigation:write";
+        case "site_settings":
+            return "data:settings:write";
+        default:
+            return "data:custom:write";
+    }
+}

package/dist/admin/plugin.d.ts

@@ -0,0 +1,4 @@
+import type { AdminPlugin } from "./types.js";
+export declare const cedrosDataPlugin: AdminPlugin;
+export { cedrosDataPlugin as dataPlugin };
+export default cedrosDataPlugin;