@ecomcx/ecomweb-content 0.0.0-stage → 1.15.0

package/dist/normalize.js

@@ -0,0 +1,147 @@
+import { blockNodeSpec, migrateBlockAttrs } from "./block.js";
+import { migrateContent } from "./migrate.js";
+import { CORE_MARKS, CORE_NODES, normalizeAttrs } from "./schema.js";
+import { normalizeAnchor, normalizeBlockStyleName, normalizeClassName, normalizeStyle } from "./style.js";
+import { normalizeBindings, normalizeLock, normalizeTemplateLock } from "./bindings.js";
+import { CONTENT_VERSION } from "./types.js";
+const empty = () => ({ version: CONTENT_VERSION, blocks: [] });
+const isObj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+/**
+ * Chuẩn hoá nội dung về định dạng của CMS. Nhận: {version, blocks}, cây TipTap/ProseMirror thuần (`type: "doc"`),
+ * chuỗi HTML. Sửa cấu trúc sai (bỏ nút không hợp lệ, ép kiểu thuộc tính khối lõi, bỏ null), giữ nguyên khối/nút lạ.
+ * Chạy hai lần cho cùng kết quả (idempotent). Máy chủ chạy cùng quy tắc (ContentFormat.cs).
+ */
+export function normalizeContent(input, options = {}) {
+    const issues = [];
+    const state = { count: 0, issues, maxDepth: options.maxDepth ?? 64, maxNodes: options.maxNodes ?? 100_000,
+        nodes: { ...CORE_NODES, ...options.nodes, ...Object.fromEntries((options.blocks ?? []).map((b) => [b.name, blockNodeSpec(b)])) },
+        marks: { ...CORE_MARKS, ...options.marks }, blocks: new Map((options.blocks ?? []).map((b) => [b.name, b])) };
+    if (input == null)
+        return { doc: empty(), issues };
+    if (typeof input === "string")
+        return { doc: { version: CONTENT_VERSION, blocks: input ? [{ id: "main", type: "html", data: { html: input } }] : [] }, issues };
+    if (!isObj(input)) {
+        issues.push("content is not an object");
+        return { doc: empty(), issues };
+    }
+    if (input.type === "doc")
+        input = { version: CONTENT_VERSION, blocks: [{ id: "main", type: "richtext", data: input }] };
+    const raw = input;
+    if (!Array.isArray(raw.blocks)) {
+        issues.push("content has no blocks");
+        return { doc: empty(), issues };
+    }
+    const version = typeof raw.version === "number" && Number.isInteger(raw.version) && raw.version > 0 ? raw.version : CONTENT_VERSION;
+    const blocks = [];
+    for (const b of raw.blocks) {
+        const block = normalizeBlock(b, state);
+        if (block)
+            blocks.push(block);
+    }
+    return { doc: migrateContent({ version, blocks }, issues), issues };
+}
+function normalizeBlock(b, state) {
+    if (!isObj(b) || typeof b.type !== "string" || !b.type || b.type.length > 100) {
+        state.issues.push("dropped invalid block");
+        return null;
+    }
+    let data;
+    switch (b.type) {
+        case "richtext": {
+            const node = normalizeNode(b.data, 0, state);
+            if (!node || node.type !== "doc")
+                state.issues.push("richtext block without doc");
+            data = node && node.type === "doc" ? node : { type: "doc" };
+            break;
+        }
+        case "html":
+            data = { html: isObj(b.data) && typeof b.data.html === "string" ? b.data.html : "" };
+            break;
+        default:
+            // Khối của plugin: dữ liệu do plugin quyết định — giữ nguyên (kể cả khi plugin đã tắt)
+            data = b.data === undefined ? null : b.data;
+    }
+    return typeof b.id === "string" && b.id ? { id: b.id, type: b.type, data } : { type: b.type, data };
+}
+function normalizeNode(node, depth, state) {
+    if (!isObj(node) || typeof node.type !== "string" || !node.type) {
+        state.issues.push("dropped node without type");
+        return null;
+    }
+    if (depth > state.maxDepth) {
+        state.issues.push(`dropped node deeper than ${state.maxDepth}`);
+        return null;
+    }
+    if (++state.count > state.maxNodes) {
+        if (state.count === state.maxNodes + 1)
+            state.issues.push(`content truncated at ${state.maxNodes} nodes`);
+        return null;
+    }
+    if (node.type === "text") {
+        if (typeof node.text !== "string" || node.text === "") {
+            state.issues.push("dropped empty text node");
+            return null;
+        }
+        const marks = normalizeMarks(node.marks, state);
+        return marks ? { type: "text", text: node.text, marks } : { type: "text", text: node.text };
+    }
+    const out = { type: node.type };
+    const def = state.blocks.get(node.type);
+    let raw = node.attrs;
+    if (def && def.version > 1) {
+        try {
+            raw = migrateBlockAttrs(def, (isObj(raw) ? raw : {}));
+        }
+        catch (e) {
+            state.issues.push(`block ${node.type}: migrate failed (${e.message}) — kept as is`);
+        }
+    }
+    const attrs = normalizeAttrs(raw, state.nodes[node.type]?.attrs);
+    // Kiểu dáng của khối (mọi khối, kể cả khối plugin): chỉ giữ giá trị hợp lệ
+    if (attrs && "style" in attrs) {
+        const style = normalizeStyle(attrs.style);
+        if (style)
+            attrs.style = style;
+        else
+            delete attrs.style;
+    }
+    // Biến thể kiểu, neo, class riêng (mọi khối)
+    for (const [k, fn] of [["blockStyle", normalizeBlockStyleName], ["anchor", normalizeAnchor], ["className", normalizeClassName], ["bindings", normalizeBindings], ["lock", normalizeLock], ["templateLock", normalizeTemplateLock]]) {
+        if (attrs && k in attrs) {
+            const v = fn(attrs[k]);
+            if (v === undefined)
+                delete attrs[k];
+            else
+                attrs[k] = v;
+        }
+    }
+    if (attrs && Object.keys(attrs).length)
+        out.attrs = attrs;
+    if (Array.isArray(node.content)) {
+        const children = [];
+        for (const c of node.content) {
+            const child = normalizeNode(c, depth + 1, state);
+            if (child)
+                children.push(child);
+        }
+        if (children.length)
+            out.content = children;
+    }
+    return out;
+}
+function normalizeMarks(marks, state) {
+    if (!Array.isArray(marks))
+        return undefined;
+    const out = [];
+    for (const m of marks) {
+        if (!isObj(m) || typeof m.type !== "string" || !m.type) {
+            state.issues.push("dropped invalid mark");
+            continue;
+        }
+        if (out.some((x) => x.type === m.type))
+            continue; // cùng một định dạng hai lần
+        const attrs = normalizeAttrs(m.attrs, state.marks[m.type]?.attrs);
+        out.push(attrs ? { type: m.type, attrs } : { type: m.type });
+    }
+    return out.length ? out : undefined;
+}

package/dist/schema.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Mô tả thuộc tính của khối / định dạng chữ — dùng cho khối lõi dưới đây và cho khối của plugin (defineBlock).
+ * Giá trị sai kiểu được ép về đúng kiểu nếu được (số dạng chuỗi → số), không ép được thì bỏ (= giá trị mặc định).
+ * `null` và "không có" là một: thuộc tính null không được lưu.
+ */
+export type AttrType = "string" | "number" | "integer" | "boolean" | "url" | "json";
+export interface AttrSpec {
+    type: AttrType;
+    /** Giá trị khi không có — trình soạn và website dùng chung. */
+    default?: unknown;
+    /** Chỉ nhận các giá trị này. */
+    enum?: readonly unknown[];
+    /** Số: kẹp trong [min, max]. */
+    min?: number;
+    max?: number;
+}
+export interface NodeSpec {
+    attrs?: Record<string, AttrSpec>;
+}
+/**
+ * Khối lõi trong nội dung soạn thảo (khối `richtext`). Thuộc tính không có trong danh sách vẫn được giữ nguyên
+ * (plugin có thể thêm thuộc tính vào khối lõi) — chỉ thuộc tính có mô tả mới được kiểm kiểu.
+ */
+export declare const CORE_NODES: Record<string, NodeSpec>;
+/** Khối động: nội dung lấy theo ngữ cảnh lúc hiển thị (website, trang, bài trong vòng lặp). */
+export declare const DYNAMIC_NODES: readonly ["siteTitle", "siteLogo", "siteTagline", "navigation", "search", "languageSwitcher", "copyright", "postTitle", "postContent", "postExcerpt", "featuredImage", "postDate", "postAuthor", "postTerms", "comments", "queryTitle", "termDescription", "breadcrumbs", "postNavigation", "query", "postTemplate", "pagination", "queryEmpty", "templatePart", "syncedPattern"];
+export declare const CORE_MARKS: Record<string, NodeSpec>;
+/** Ép giá trị theo mô tả. Trả về undefined = bỏ thuộc tính (dùng mặc định). */
+export declare function coerceAttr(spec: AttrSpec, value: unknown): unknown;
+/** Chuẩn hoá bộ thuộc tính: ép kiểu thuộc tính có mô tả, giữ nguyên thuộc tính khác, bỏ null. Rỗng → undefined. */
+export declare function normalizeAttrs(attrs: unknown, spec?: Record<string, AttrSpec>): Record<string, unknown> | undefined;

package/dist/schema.js

@@ -0,0 +1,173 @@
+const s = (extra = {}) => ({ type: "string", ...extra });
+const n = (extra = {}) => ({ type: "number", ...extra });
+const i = (extra = {}) => ({ type: "integer", ...extra });
+const b = (extra = {}) => ({ type: "boolean", ...extra });
+const url = () => ({ type: "url" });
+const align = s({ enum: ["left", "center", "right", "justify"] });
+const media = { src: url(), name: s(), mime: s(), mediaId: { type: "json" }, caption: s() };
+/**
+ * Khối lõi trong nội dung soạn thảo (khối `richtext`). Thuộc tính không có trong danh sách vẫn được giữ nguyên
+ * (plugin có thể thêm thuộc tính vào khối lõi) — chỉ thuộc tính có mô tả mới được kiểm kiểu.
+ */
+export const CORE_NODES = {
+    doc: {},
+    text: {},
+    paragraph: { attrs: { textAlign: align } },
+    heading: { attrs: { level: i({ min: 1, max: 6, default: 2 }), textAlign: align, id: s() } },
+    bulletList: {},
+    orderedList: { attrs: { start: i({ min: 0, default: 1 }) } },
+    listItem: {},
+    taskList: {},
+    taskItem: { attrs: { checked: b({ default: false }) } },
+    blockquote: {},
+    codeBlock: { attrs: { language: s() } },
+    hardBreak: {},
+    horizontalRule: {},
+    image: {
+        attrs: {
+            src: url(), alt: s(), title: s(), width: n({ min: 1 }), height: n({ min: 1 }), srcset: s(), webpSrcset: s(),
+            mediaId: { type: "json" }, size: s({ default: "large" }), caption: s(), align: s({ enum: ["left", "right", "center", "wide", "full"] }),
+        },
+    },
+    gallery: { attrs: { images: { type: "json", default: [] }, columns: i({ min: 1, max: 6, default: 3 }), caption: s() } },
+    video: { attrs: { ...media, poster: url() } },
+    audio: { attrs: { ...media } },
+    file: { attrs: { ...media, size: n({ min: 0 }), embed: b({ default: true }), download: b() } },
+    table: { attrs: { footer: b({ default: false }), fixed: b({ default: false }) } },
+    tableRow: {},
+    tableHeader: { attrs: { colspan: i({ min: 1, default: 1 }), rowspan: i({ min: 1, default: 1 }), colwidth: { type: "json" } } },
+    tableCell: { attrs: { colspan: i({ min: 1, default: 1 }), rowspan: i({ min: 1, default: 1 }), colwidth: { type: "json" } } },
+    youtube: { attrs: { src: url(), start: i({ min: 0 }), width: n({ min: 1 }), height: n({ min: 1 }) } },
+    // Bố cục (1.2): cột, nhóm, hộp lưu ý chứa khối khác; nút; nhúng theo đường dẫn (embedInfo)
+    columns: { attrs: { verticalAlign: s({ enum: ["top", "center", "bottom"] }), stack: b({ default: true }) } },
+    column: { attrs: { width: n({ min: 5, max: 100 }) } },
+    group: { attrs: { background: s(), textColor: s(), padding: s({ enum: ["none", "small", "medium", "large"], default: "medium" }) } },
+    callout: { attrs: { tone: s({ enum: ["info", "success", "warning", "danger"], default: "info" }), title: s() } },
+    button: {
+        attrs: {
+            text: s(), href: url(), target: s(), rel: s(),
+            variant: s({ enum: ["primary", "secondary", "outline"], default: "primary" }), align: s({ enum: ["left", "center", "right"] }),
+        },
+    },
+    embed: { attrs: { url: url(), caption: s() } },
+    // Bộ khối cơ bản (1.9)
+    spacer: { attrs: { height: s({ default: "lg" }) } },
+    buttons: { attrs: { align: s({ enum: ["left", "center", "right", "space-between"] }) } },
+    cover: {
+        attrs: {
+            src: url(), mediaId: { type: "json" }, alt: s(), overlay: s(), opacity: i({ min: 0, max: 100, default: 50 }), minHeight: s({ default: "400px" }),
+            contentAlign: s({ enum: ["top", "center", "bottom"], default: "center" }), fixed: b({ default: false }),
+        },
+    },
+    mediaText: {
+        attrs: {
+            src: url(), mediaId: { type: "json" }, alt: s(), position: s({ enum: ["left", "right"], default: "left" }), width: i({ min: 20, max: 80, default: 50 }),
+            verticalAlign: s({ enum: ["top", "center", "bottom"], default: "center" }), stack: b({ default: true }),
+        },
+    },
+    pullquote: { attrs: { citation: s() } },
+    details: { attrs: { summary: s(), open: b({ default: false }) } },
+    customHtml: { attrs: { html: s() } },
+    socialLinks: { attrs: { links: { type: "json", default: [] }, size: s({ enum: ["small", "medium", "large"], default: "medium" }), align: s({ enum: ["left", "center", "right"] }), showLabels: b({ default: false }) } },
+    tableOfContents: { attrs: { title: s(), maxLevel: i({ min: 2, max: 4, default: 3 }) } },
+    preformatted: {},
+    // Khối động (1.6): lấy dữ liệu lúc hiển thị theo ngữ cảnh (website, trang đang xem, bài trong vòng lặp) — dùng trong template
+    siteTitle: { attrs: { level: i({ min: 0, max: 6, default: 0 }), link: b({ default: true }), textAlign: align } },
+    siteLogo: { attrs: { width: n({ min: 16, max: 600, default: 120 }), link: b({ default: true }) } },
+    siteTagline: { attrs: { textAlign: align } },
+    navigation: { attrs: { location: s({ default: "primary" }), orientation: s({ enum: ["horizontal", "vertical"], default: "horizontal" }), mobile: b({ default: true }) } },
+    search: { attrs: { placeholder: s(), buttonText: s() } },
+    languageSwitcher: {},
+    copyright: { attrs: { text: s(), textAlign: align } },
+    postTitle: { attrs: { level: i({ min: 1, max: 6, default: 1 }), link: b({ default: false }), textAlign: align } },
+    postContent: {},
+    postExcerpt: { attrs: { moreText: s() } },
+    featuredImage: { attrs: { size: s({ default: "large" }), link: b({ default: false }), aspect: s({ enum: ["auto", "16/9", "4/3", "1/1", "3/4"], default: "auto" }) } },
+    postDate: { attrs: { textAlign: align } },
+    postAuthor: { attrs: { avatar: b({ default: false }) } },
+    postTerms: { attrs: { taxonomy: s({ default: "category" }), separator: s({ default: ", " }) } },
+    comments: {},
+    // 1.15: khối theme cho SEO / điều hướng — H1 của trang lưu trữ, mô tả chuyên mục, breadcrumb, bài trước / sau
+    queryTitle: { attrs: { level: i({ min: 1, max: 6, default: 1 }), prefix: b({ default: false }), textAlign: align } },
+    termDescription: { attrs: { textAlign: align } },
+    breadcrumbs: { attrs: { separator: s({ default: "›" }), showHome: b({ default: true }), showCurrent: b({ default: true }) } },
+    postNavigation: { attrs: { showTitle: b({ default: true }) } },
+    query: {
+        attrs: {
+            inherit: b({ default: true }), postType: s({ default: "post" }), perPage: i({ min: 1, max: 50, default: 10 }),
+            category: s(), tag: s(), orderBy: s({ enum: ["date", "title", "menu_order"], default: "date" }), order: s({ enum: ["desc", "asc"], default: "desc" }),
+        },
+    },
+    postTemplate: { attrs: { layout: s({ enum: ["list", "grid"], default: "list" }), columns: i({ min: 1, max: 6, default: 3 }) } },
+    pagination: {},
+    queryEmpty: {},
+    templatePart: { attrs: { slug: s(), tagName: s({ enum: ["div", "header", "footer", "aside", "section"], default: "div" }) } },
+    /** Mẫu đồng bộ: tham chiếu tới mẫu (id) — sửa mẫu gốc thì mọi chỗ dùng đổi theo. */
+    syncedPattern: { attrs: { ref: i({ min: 1 }) } },
+};
+/** Khối động: nội dung lấy theo ngữ cảnh lúc hiển thị (website, trang, bài trong vòng lặp). */
+export const DYNAMIC_NODES = [
+    "siteTitle", "siteLogo", "siteTagline", "navigation", "search", "languageSwitcher", "copyright",
+    "postTitle", "postContent", "postExcerpt", "featuredImage", "postDate", "postAuthor", "postTerms", "comments",
+    "queryTitle", "termDescription", "breadcrumbs", "postNavigation",
+    "query", "postTemplate", "pagination", "queryEmpty", "templatePart", "syncedPattern",
+];
+export const CORE_MARKS = {
+    bold: {}, italic: {}, underline: {}, strike: {}, code: {}, subscript: {}, superscript: {},
+    highlight: { attrs: { color: s() } },
+    textStyle: { attrs: { color: s() } },
+    link: { attrs: { href: url(), target: s(), rel: s() } },
+};
+/** Ép giá trị theo mô tả. Trả về undefined = bỏ thuộc tính (dùng mặc định). */
+export function coerceAttr(spec, value) {
+    if (value === null || value === undefined)
+        return undefined;
+    let v = value;
+    switch (spec.type) {
+        case "string":
+        case "url":
+            if (typeof v === "number" || typeof v === "boolean")
+                v = String(v);
+            if (typeof v !== "string")
+                return undefined;
+            break;
+        case "number":
+        case "integer": {
+            const num = typeof v === "number" ? v : typeof v === "string" && v.trim() !== "" ? Number(v) : NaN;
+            if (!Number.isFinite(num))
+                return undefined;
+            let x = spec.type === "integer" ? Math.round(num) : num;
+            if (spec.min !== undefined)
+                x = Math.max(spec.min, x);
+            if (spec.max !== undefined)
+                x = Math.min(spec.max, x);
+            v = x;
+            break;
+        }
+        case "boolean":
+            if (v === "true")
+                v = true;
+            else if (v === "false")
+                v = false;
+            if (typeof v !== "boolean")
+                return undefined;
+            break;
+        case "json":
+            break;
+    }
+    if (spec.enum && !spec.enum.includes(v))
+        return undefined;
+    return v;
+}
+/** Chuẩn hoá bộ thuộc tính: ép kiểu thuộc tính có mô tả, giữ nguyên thuộc tính khác, bỏ null. Rỗng → undefined. */
+export function normalizeAttrs(attrs, spec) {
+    if (!attrs || typeof attrs !== "object" || Array.isArray(attrs))
+        return undefined;
+    const out = {};
+    for (const [key, value] of Object.entries(attrs)) {
+        const v = spec?.[key] ? coerceAttr(spec[key], value) : value === null ? undefined : value;
+        if (v !== undefined)
+            out[key] = v;
+    }
+    return Object.keys(out).length ? out : undefined;
+}

package/dist/style.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Kiểu dáng của khối (`attrs.style`, mọi khối): khoảng cách, cỡ chữ, màu, viền, ẩn theo khổ màn hình.
+ * Giá trị theo khổ: `{ base, tablet, mobile }` (tablet ≤ 1024px, mobile ≤ 640px). Giá trị là preset của theme
+ * (`lg`, `primary` → biến CSS `--ecx-spacing-lg`, `--ecx-color-primary`) hoặc giá trị CSS đã kiểm (độ dài, màu).
+ * Chỉ nhận giá trị trong danh sách → không chèn được CSS tuỳ ý. Máy chủ chạy cùng quy tắc (ContentFormat.cs).
+ */
+export declare const BREAKPOINTS: {
+    readonly tablet: 1024;
+    readonly mobile: 640;
+};
+export declare const DEVICES: readonly ["base", "tablet", "mobile"];
+export type Device = (typeof DEVICES)[number];
+export type Responsive<T> = Partial<Record<Device, T>>;
+export type Box = string | Partial<Record<"top" | "right" | "bottom" | "left", string>>;
+export interface BlockStyle {
+    padding?: Responsive<Box>;
+    margin?: Responsive<Box>;
+    gap?: Responsive<string>;
+    width?: Responsive<string>;
+    maxWidth?: Responsive<string>;
+    minHeight?: Responsive<string>;
+    fontFamily?: string;
+    fontSize?: Responsive<string>;
+    lineHeight?: Responsive<number>;
+    letterSpacing?: Responsive<string>;
+    fontWeight?: string;
+    fontStyle?: string;
+    textDecoration?: string;
+    textTransform?: string;
+    textAlign?: Responsive<string>;
+    color?: {
+        text?: string;
+        background?: string;
+    };
+    border?: {
+        width?: string;
+        style?: string;
+        color?: string;
+    };
+    radius?: string;
+    hide?: Array<"desktop" | "tablet" | "mobile">;
+    /** Bố cục khối chứa (1.15): xếp ngang/dọc (flex) hoặc lưới — khối con xếp theo đây. */
+    layout?: BlockLayout;
+    /** Nền chuyển màu (1.15): preset của theme (`brand` → --ecx-gradient-brand) hoặc linear/radial-gradient đã kiểm. */
+    gradient?: string;
+    /** Đổ bóng (1.15): preset (`sm` `md` `lg` `xl` có sẵn, theme thêm) hoặc `none`. */
+    shadow?: string;
+    /** Tỉ lệ khung (1.15). */
+    aspectRatio?: string;
+    /** Ghim khi cuộn (1.15): `{ type: "sticky", top }`. */
+    position?: {
+        type: "sticky";
+        top?: string;
+    };
+    /** Khi rê chuột (1.15): màu chữ / nền / viền, bóng, nhấc lên. */
+    hover?: {
+        color?: {
+            text?: string;
+            background?: string;
+        };
+        border?: {
+            color?: string;
+        };
+        shadow?: string;
+        lift?: boolean;
+    };
+}
+/** Bố cục của khối chứa. Không có `type` = luồng thường (khối con xếp dọc như văn bản). */
+export interface BlockLayout {
+    type: "flex" | "grid";
+    /** flex: hàng ngang (row) hoặc xếp dọc (column). */
+    direction?: Responsive<"row" | "column">;
+    justify?: Responsive<"start" | "center" | "end" | "between">;
+    align?: Responsive<"start" | "center" | "end" | "stretch">;
+    /** flex: cho xuống dòng khi hết chỗ (mặc định có). */
+    wrap?: boolean;
+    /** grid: số cột (1–12) theo khổ. */
+    columns?: Responsive<number>;
+    /** grid: không đặt số cột → tự chia cột, mỗi cột tối thiểu bằng này. */
+    minColumnWidth?: string;
+}
+/** Gradient: preset hoặc linear/radial-gradient(hướng?, 2–6 điểm màu hex/rgb/hsl kèm %) — dạng chuẩn hoá khoảng trắng. */
+export declare function normalizeGradient(v: unknown): string | undefined;
+/** Chuẩn hoá `attrs.style`: giữ đúng thứ tự khoá, bỏ giá trị không hợp lệ. Rỗng → undefined. */
+export declare function normalizeStyle(v: unknown): BlockStyle | undefined;
+/** Độ dài / preset khoảng cách hợp lệ → giá trị CSS (preset thành biến); không hợp lệ → undefined. Dùng cho thuộc tính khối như chiều cao khoảng trống. */
+export declare function spacingValue(v: unknown): string | undefined;
+/** Màu hợp lệ (hex/rgb/hsl hoặc preset) → giá trị CSS; không hợp lệ → undefined. */
+export declare function colorCss(v: unknown): string | undefined;
+/** Tên class ổn định theo nội dung style (cùng kiểu dáng → cùng class). */
+export declare function styleClass(style: BlockStyle): string;
+/** CSS của một kiểu dáng: `.cls.cls{…}` + media query cho tablet / mobile + ẩn theo khổ + :hover. Rỗng → "". */
+export declare function styleCss(style: BlockStyle, cls?: string): string;
+/**
+ * CSS của một kiểu dáng cho bộ chọn bất kỳ (danh sách cách nhau dấu phẩy) — dùng cho kiểu của từng khối và Global Styles
+ * (kiểu mặc định theo loại khối / phần tử). Bộ chọn do mã gọi đưa vào, không lấy từ dữ liệu người dùng.
+ */
+export declare function ruleCss(selector: string, style: BlockStyle): string;
+/** Gom CSS cho cả một cây nội dung: trả về css (mỗi class một lần) — website và trình soạn dùng chung. */
+export declare function collectStyles(styles: Iterable<BlockStyle>): string;
+/** Biến thể kiểu (`blockStyle`): tên preset → class `ecx-is-<tên>`. */
+export declare function normalizeBlockStyleName(v: unknown): string | undefined;
+/** Neo (`anchor`) → id của phần tử. */
+export declare function normalizeAnchor(v: unknown): string | undefined;
+/** Class CSS riêng (`className`): tối đa 5 class hợp lệ, cách nhau bởi dấu cách. */
+export declare function normalizeClassName(v: unknown): string | undefined;
+/** Biến thể có sẵn của lõi (CSS trong style.css); theme thêm bằng theme.json › blockStyles. */
+export declare const CORE_BLOCK_STYLES: Record<string, string[]>;
+export interface StylePresets {
+    colors?: Record<string, string>;
+    fontSizes?: Record<string, string>;
+    spacing?: Record<string, string>;
+    fonts?: Record<string, string>;
+    /** 1.15: nền chuyển màu (linear/radial-gradient đã kiểm) → --ecx-gradient-*. */
+    gradients?: Record<string, string>;
+    /** 1.15: đổ bóng (tối đa 3 lớp "x y blur spread? màu") → --ecx-shadow-*. */
+    shadows?: Record<string, string>;
+    /** 1.15 Global Styles: kiểu mặc định theo loại khối (paragraph, heading, button, group…). */
+    blocks?: Record<string, BlockStyle>;
+    /** 1.15 Global Styles: kiểu mặc định theo phần tử (link, button, heading, h1–h6, caption). */
+    elements?: Record<string, BlockStyle>;
+}
+/** Bộ chọn của khối lõi trên website (markup của renderer) — Global Styles theo loại khối. */
+export declare const BLOCK_SELECTORS: Record<string, string>;
+/** Bộ chọn của phần tử — Global Styles theo phần tử. */
+export declare const ELEMENT_SELECTORS: Record<string, string>;
+/** Chuẩn hoá preset: tên preset hợp lệ, giá trị đã kiểm (màu hex/rgb/hsl, độ dài hoặc clamp(), danh sách phông không có ; { }). */
+export declare function normalizePresets(v: unknown): StylePresets;
+/** Gộp preset theo thứ tự (sau đè trước): theme → bản sửa của quản trị viên. */
+export declare function mergePresets(...list: unknown[]): StylePresets;
+/** Biến CSS của preset: `--ecx-color-*`, `--ecx-font-size-*`, `--ecx-spacing-*`, `--ecx-font-family-*`. */
+export declare function presetCss(presets: unknown, selector?: string): string;