nextjs-cms 0.0.1 → 0.5.1

package/dist/core/sections/section.js

@@ -0,0 +1,341 @@
+import { entityKind } from '../helpers';
+import { numberField } from '../fields';
+import chalk from 'chalk';
+import * as z from 'zod';
+import { getCMSConfig } from '../config/config-loader';
+const cmsConfig = getCMSConfig();
+export const fieldConfigSchema = z.custom();
+export const FieldGroupConfigSchema = z.custom();
+const variantSchema = z.custom();
+const hooksSchema = z.custom();
+export const baseSectionOptionsSchema = z.strictObject({
+    name: z.string().describe('The name of the section'),
+    order: z.number(),
+    icon: z.string().optional(),
+    readonly: z.boolean().default(false).optional(),
+    gallery: z
+        .strictObject({
+        db: z.strictObject({
+            tableName: z.string(),
+            identifierField: z.string().optional(),
+            photoNameField: z.string().optional(),
+            metaField: z.string().optional(),
+        }),
+        watermark: z.boolean().optional(),
+        thumbnail: z
+            .strictObject({
+            width: z.number(),
+            height: z.number(),
+            crop: z.boolean(),
+            quality: z.number(),
+        })
+            .optional(),
+    })
+        .optional(),
+    db: z.strictObject({
+        table: z.string(),
+        identifier: fieldConfigSchema.optional(),
+        orderByField: fieldConfigSchema.optional(),
+        primaryKey: z.array(fieldConfigSchema).optional(),
+        foreignKeys: z
+            .array(z.strictObject({
+            columns: z.array(fieldConfigSchema),
+            foreignColumns: z.array(fieldConfigSchema),
+            name: z.string(),
+        }))
+            .optional(),
+        index: z
+            .array(z.strictObject({
+            columns: z.array(fieldConfigSchema),
+            name: z.string().optional(),
+        }))
+            .optional(),
+        unique: z
+            .array(z.strictObject({
+            columns: z.array(fieldConfigSchema),
+            name: z.string().optional(),
+        }))
+            .optional(),
+        fulltext: z
+            .array(z.strictObject({
+            columns: z.array(fieldConfigSchema),
+            name: z.string().optional(),
+        }))
+            .optional(),
+    }),
+    fields: z.array(fieldConfigSchema),
+    fieldGroups: z.array(FieldGroupConfigSchema).optional(),
+    variants: z.array(variantSchema).optional(),
+    hooks: hooksSchema.optional(),
+});
+/**
+ * This is the options schema for the helper functions that create section configs
+ * We omit the fields and fieldGroups properties from the baseSectionOptionsSchema
+ *  and change the fields to be an array of field configs or field group configs
+ */
+export const baseHelperFunctionOptionsSchema = z.strictObject({
+    ...baseSectionOptionsSchema.omit({ fields: true, fieldGroups: true }).shape,
+    fields: z
+        .array(fieldConfigSchema)
+        .min(1)
+        .describe('The fields of the section')
+        .or(z
+        .array(FieldGroupConfigSchema)
+        .min(1)
+        .describe('The field groups of the section')
+        .describe('The fields or field groups of the section')),
+});
+export function validateSectionConfig(config) {
+    const result = baseSectionOptionsSchema.safeParse(config);
+    if (!result.success) {
+        throw new Error(result.error.message);
+    }
+}
+export class Section {
+    static [entityKind] = 'Section';
+    name;
+    order;
+    icon;
+    readonly = false;
+    gallery;
+    _fields = undefined;
+    _fieldGroupConfigs = undefined;
+    _hasFieldGroups;
+    _fieldGroups = undefined;
+    _fieldConfigs;
+    /**
+     * A helper property to access the field configs.
+     * Sometimes it's handy to access the field configs without building the actual fields array.
+     */
+    get fieldConfigs() {
+        return this._fieldConfigs ?? [];
+    }
+    get fieldGroups() {
+        return this._fieldGroups ?? [];
+    }
+    get fields() {
+        if (this._fields === undefined) {
+            const errorMessage = `Fields are not yer built for section "${this.name}". Please run buildFields() before accessing the fields property.`;
+            const reportMessage = 'If this is a system bug, please open a bug report on GitHub.';
+            console.error('\n');
+            console.error(chalk.bold.red('[Section Error]', errorMessage));
+            console.error(chalk.bold.bgRed(reportMessage));
+            console.error('\n');
+            throw new Error(errorMessage);
+        }
+        return this._fields;
+    }
+    set fields(value) {
+        this._fields = value;
+    }
+    db;
+    variants;
+    hooks;
+    constructor(config) {
+        // this.id = config.id
+        this.name = config.name;
+        this.order = config.order;
+        this.icon = config.icon;
+        this.readonly = config.readonly ?? false;
+        /**
+         * Resolve gallery config
+         */
+        if (config.gallery) {
+            this.gallery = {
+                db: {
+                    tableName: config.gallery.db.tableName,
+                    referenceIdentifierField: config.gallery.db.identifierField ?? 'reference_id',
+                    photoNameField: config.gallery.db.photoNameField ?? 'photo',
+                    metaField: config.gallery.db.metaField ?? 'meta',
+                },
+                watermark: config.gallery.watermark ?? cmsConfig.files.images.watermark,
+                thumbnail: config.gallery.thumbnail ?? cmsConfig.files.images.thumbnail,
+            };
+        }
+        /**
+         * Check for db identifier field config
+         */
+        if (!config.db.identifier) {
+            // Create default id field config
+            const idFieldConfig = numberField({
+                name: 'id',
+                label: 'ID',
+                required: true,
+                hasAutoIncrement: true,
+                order: 0,
+            });
+            config.db.identifier = idFieldConfig;
+            config.fields.unshift(idFieldConfig);
+        }
+        else {
+            /**
+             * Make sure the identifier field config is a number or text field config
+             */
+            if (config.db.identifier.type !== 'number' && config.db.identifier.type !== 'text') {
+                const message = `[Section: ${this.name}]: DB identifier field config must be a number or text field. Got type: ${config.db.identifier.type}`;
+                console.error(chalk.red.bold(message));
+                console.error(chalk.yellow('Please make sure the identifier field config is a number or text field.'));
+                throw new Error(message);
+            }
+        }
+        /**
+         * Resolve db configuration fields
+         * If user doesn't specify primaryKey, default to identifier field
+         */
+        this.db = {
+            table: config.db.table,
+            identifier: config.db.identifier,
+            orderByField: config.db.orderByField,
+            primaryKey: config.db.primaryKey ?? [config.db.identifier],
+            foreignKeys: config.db.foreignKeys,
+            fulltext: config.db.fulltext,
+            index: config.db.index,
+            unique: config.db.unique ?? [],
+        };
+        /**
+         * Add the identifier field to the unique array if it's not already there
+         */
+        if (!this.db.unique.some((unique) => unique.columns.includes(this.db.identifier))) {
+            /**
+             * Add the identifier field as the first item in the unique array
+             */
+            this.db.unique.unshift({ columns: [this.db.identifier] });
+        }
+        this._fieldConfigs = config.fields;
+        this._fieldGroupConfigs = config.fieldGroups;
+        // Cache the hasFieldGroups check once during construction (immutable after this point)
+        this._hasFieldGroups = (this._fieldGroupConfigs?.length ?? 0) > 0;
+        this.variants = config.variants;
+        this.hooks = config.hooks;
+    }
+    /**
+     * Returns whether this section has field groups.
+     * Value is cached during construction for optimal performance.
+     */
+    get hasFieldGroups() {
+        return this._hasFieldGroups;
+    }
+    buildFieldGroups() {
+        const configs = this._fieldGroupConfigs;
+        if (!configs?.length)
+            return;
+        const fieldGroups = [];
+        const fields = [];
+        configs.forEach((groupConfig, index) => {
+            const fields = groupConfig.fields.map((fieldConfig) => this.resolveField(fieldConfig));
+            fieldGroups.push({
+                id: index + 1,
+                title: groupConfig.title,
+                order: groupConfig.order,
+                fields,
+            });
+            fields.push(...fields);
+        });
+        this._fieldGroups = fieldGroups;
+        this._fields = fields;
+    }
+    buildFields() {
+        if (this.hasFieldGroups) {
+            this.buildFieldGroups();
+            return;
+        }
+        if (this._fieldConfigs === undefined) {
+            throw new Error(`This section: (${this.name}) has no fields. Please set at least one field.`);
+        }
+        this._fields = this._fieldConfigs.map((input) => this.resolveField(input));
+        /**
+         * Create one group to hold all the fields
+         */
+        this._fieldGroups = [
+            {
+                id: 1,
+                title: '',
+                order: 1,
+                fields: this._fields,
+            },
+        ];
+    }
+    /**
+     * Helper function to resolve a field config to an instance
+     * by calling the build() method on the config
+     * @param config - The field config to resolve
+     * @returns The field instance
+     * @throws An error if the field config does not have a build() method
+     */
+    resolveField(config) {
+        // Config must have a build() method
+        if (typeof config.build === 'function') {
+            return config.build();
+        }
+        throw new Error(`[Section: ${this.name}]: Field "${config.name}" config must have a build() method. Use helper functions like textField(), numberField(), etc. to create field configs.`);
+    }
+}
+/**
+ * Helper function to ensure a section config has a db identifier field
+ * If db.identifier is missing, creates a default 'id' number field config
+ * and prepends it to fields and sets it as db.identifier
+ *
+ * @param section - Section config that may or may not have db.identifier
+ * @returns Section config with db.identifier guaranteed to exist
+ */
+export function ensureSectionDbIdentifier(section) {
+    // If identifier already exists, return as-is
+    if (section.db.identifier) {
+        return section;
+    }
+    // Create default id field config
+    const idFieldConfig = numberField({
+        name: 'id',
+        label: 'ID',
+        required: true,
+        hasAutoIncrement: true,
+        order: 0,
+    });
+    // Return modified config with identifier
+    return {
+        ...section,
+        fields: [idFieldConfig, ...section.fields],
+        db: {
+            ...section.db,
+            identifier: idFieldConfig,
+        },
+    };
+}
+/**
+ * Helper function to normalize gallery config with default values
+ * Sets defaults for identifierField, photoNameField, and metaField if not provided
+ *
+ * @param section - Section config that may or may not have gallery config
+ * @returns Section config with normalized gallery config
+ */
+export function ensureSectionGallery(section) {
+    // If no gallery config, return as-is
+    if (!section.gallery) {
+        return section;
+    }
+    // Return config with normalized gallery
+    return {
+        ...section,
+        gallery: {
+            ...section.gallery,
+            db: {
+                tableName: section.gallery.db.tableName,
+                identifierField: section.gallery.db.identifierField ?? 'reference_id',
+                photoNameField: section.gallery.db.photoNameField ?? 'photo',
+                metaField: section.gallery.db.metaField ?? 'meta',
+            },
+        },
+    };
+}
+export function resolveFieldsAndFieldGroups(config) {
+    if (config.fields.length) {
+        return {
+            fields: config.fields,
+            fieldGroups: [],
+        };
+    }
+    return {
+        fields: config.fieldGroups.flatMap((group) => group.fields),
+        fieldGroups: config.fieldGroups,
+    };
+}

package/dist/core/sections/simple.d.ts

@@ -0,0 +1,99 @@
+import { entityKind } from '../helpers';
+import type { BaseSectionOptions } from './section';
+import { Section } from './section';
+import { FieldGroupConfig, type FieldConfig } from '../fields';
+import * as z from 'zod';
+declare const configSchema: z.ZodObject<{
+    title: z.ZodString;
+    db: z.ZodObject<{
+        table: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type Config = z.infer<typeof configSchema>;
+export declare class SimpleSection extends Section<Config> {
+    static readonly [entityKind] = "SimpleSection";
+    readonly type = "simple";
+    title: string;
+    constructor(config: BaseSectionOptions<Config>);
+}
+declare const optionsSchema: z.ZodObject<{
+    title: z.ZodString;
+    db: z.ZodObject<{
+        table: z.ZodString;
+    }, z.core.$strict>;
+    fields: z.ZodUnion<[z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>, z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>]>;
+    variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").Variant, import("../types").Variant>>>;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            crop: z.ZodBoolean;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    hooks: z.ZodOptional<z.ZodCustom<import("./section").Hooks, import("./section").Hooks>>;
+}, z.core.$strict>;
+declare const simpleSectionConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"simple">;
+    fields: z.ZodArray<z.ZodCustom<FieldConfig, FieldConfig>>;
+    build: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodCustom<SimpleSection, SimpleSection>>;
+    fieldGroups: z.ZodOptional<z.ZodArray<z.ZodCustom<FieldGroupConfig, FieldGroupConfig>>>;
+    title: z.ZodString;
+    db: z.ZodObject<{
+        table: z.ZodString;
+    }, z.core.$strict>;
+    variants: z.ZodOptional<z.ZodArray<z.ZodCustom<import("../types").Variant, import("../types").Variant>>>;
+    name: z.ZodString;
+    order: z.ZodNumber;
+    readonly: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+    icon: z.ZodOptional<z.ZodString>;
+    gallery: z.ZodOptional<z.ZodObject<{
+        db: z.ZodObject<{
+            tableName: z.ZodString;
+            identifierField: z.ZodOptional<z.ZodString>;
+            photoNameField: z.ZodOptional<z.ZodString>;
+            metaField: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        watermark: z.ZodOptional<z.ZodBoolean>;
+        thumbnail: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+            crop: z.ZodBoolean;
+            quality: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    hooks: z.ZodOptional<z.ZodCustom<import("./section").Hooks, import("./section").Hooks>>;
+}, z.core.$strict>;
+export type SimpleSectionOptions = z.infer<typeof optionsSchema>;
+/**
+ * Simple section configuration
+ * This is the output of the simpleSection() helper function, it that can be serialized and used anywhere
+ * The build() method allows creating a SimpleSection instance when needed
+ */
+export type SimpleSectionConfig = z.infer<typeof simpleSectionConfigSchema>;
+/**
+ * Helper function to create a simple section configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const sectionConfig = simpleSection({ name: 'settings', ... })
+ * const sectionInstance = sectionConfig.build()
+ * ```
+ *
+ * @param section
+ */
+export declare function simpleSection(section: SimpleSectionOptions): SimpleSectionConfig;
+export {};
+//# sourceMappingURL=simple.d.ts.map

package/dist/core/sections/simple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../../src/core/sections/simple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAA;AACnD,OAAO,EAAmC,OAAO,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,EAAE,gBAAgB,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAA;AAC9D,OAAO,KAAK,CAAC,MAAM,KAAK,CAAA;AAGxB,QAAA,MAAM,YAAY;;;;;kBAiBhB,CAAA;AAEF,KAAK,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAE1C,qBAAa,aAAc,SAAQ,OAAO,CAAC,MAAM,CAAC;IAC9C,gBAAyB,CAAC,UAAU,CAAC,mBAAkB;IACvD,SAAkB,IAAI,YAAW;IACxB,KAAK,EAAE,MAAM,CAAA;gBAEV,MAAM,EAAE,kBAAkB,CAAC,MAAM,CAAC;CAIjD;AAED,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGjB,CAAA;AAOF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7B,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AAEhE;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAA;AAE3E;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CA6ChF"}

package/dist/core/sections/simple.js

@@ -0,0 +1,95 @@
+import { entityKind } from '../helpers';
+import { baseHelperFunctionOptionsSchema, Section } from './section';
+import * as z from 'zod';
+import { FieldGroupConfigSchema, fieldConfigSchema } from './section';
+const configSchema = z.strictObject({
+    title: z.string('Section title is required').describe('The title of the section'),
+    db: z
+        .strictObject({
+        table: z
+            .string('Table name is required')
+            .describe('The name of the database table to use for this section'),
+    }, {
+        error: 'DB configuration is required',
+    })
+        .describe('In simple sections, the identifier field is a number field with the name `id`, and always has the value of 1 in the database table')
+        .describe('The database configuration for this section'),
+});
+export class SimpleSection extends Section {
+    static [entityKind] = 'SimpleSection';
+    type = 'simple';
+    title;
+    constructor(config) {
+        super(config);
+        this.title = config.title;
+    }
+}
+const optionsSchema = z.strictObject({
+    ...baseHelperFunctionOptionsSchema.shape,
+    ...configSchema.shape,
+});
+const compiledOptionsSchema = z.strictObject({
+    ...optionsSchema.shape,
+    fieldGroups: z.array(FieldGroupConfigSchema).optional().describe('The field groups of the section if provided'),
+});
+const simpleSectionConfigSchema = z.strictObject({
+    ...compiledOptionsSchema.shape,
+    type: z.literal('simple').describe('The type of the section'),
+    fields: z.array(fieldConfigSchema).describe('The fields of the section'),
+    build: z.function().output(z.instanceof(SimpleSection)).describe('Build a SimpleSection instance from this config'),
+});
+/**
+ * Helper function to create a simple section configuration
+ * Returns a config object with a build() method that can be serialized and used anywhere
+ *
+ * @example
+ * ```typescript
+ * const sectionConfig = simpleSection({ name: 'settings', ... })
+ * const sectionInstance = sectionConfig.build()
+ * ```
+ *
+ * @param section
+ */
+export function simpleSection(section) {
+    /**
+     * Validate the section config
+     */
+    const result = optionsSchema.safeParse(section);
+    if (!result.success) {
+        throw new Error(`[Section: ${section.name}]: ${z.prettifyError(result.error)}`);
+    }
+    /**
+     * Resolve fields and fieldGroups
+     */
+    let fields = [];
+    let fieldGroups = [];
+    if (section.fields && section.fields.length > 0) {
+        const firstInput = section.fields[0];
+        /**
+         * Check if the first item is a field group.
+         * We don't need to check every item,
+         * because zod already validated the fields array.
+         */
+        if (firstInput && 'fields' in firstInput) {
+            fieldGroups = section.fields;
+            fields = fieldGroups.flatMap((group) => group.fields);
+        }
+        else {
+            fields = section.fields;
+        }
+    }
+    const config = {
+        ...section,
+        fields,
+        fieldGroups: fieldGroups.length > 0 ? fieldGroups : undefined,
+        type: 'simple',
+        build() {
+            return new SimpleSection({
+                ...section,
+                fields,
+                fieldGroups: fieldGroups.length > 0 ? fieldGroups : undefined,
+            });
+        },
+    };
+    return config;
+}

package/dist/core/security/dom.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Escape a string so it can be safely injected into an HTML text context.
+ * Returns `undefined` when the input is `undefined` or `null` to preserve caller intent.
+ */
+export declare function escapeHTML(value: string | undefined | null): string | undefined;
+/**
+ * Sanitize rich-text/HTML content using DOMPurify with a restrictive allow-list.
+ * Always returns a string (empty string when value is undefined or null).
+ */
+export declare function sanitizeRichText(value: string | undefined | null): string;
+//# sourceMappingURL=dom.d.ts.map

package/dist/core/security/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../../src/core/security/dom.ts"],"names":[],"mappings":"AAgBA;;;GAGG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAU/E;AA+DD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAAG,MAAM,CAMzE"}

package/dist/core/security/dom.js

@@ -0,0 +1,92 @@
+import DOMPurify from 'isomorphic-dompurify';
+const HTML_ESCAPE_LOOKUP = {
+    '&': '&',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '/': '&#x2F;',
+    '`': '&#x60;',
+    '/\/': '&#x2F;',
+};
+const HTML_ESCAPE_REGEX = /[&<>"'\/`\/\/]/g;
+/**
+ * Escape a string so it can be safely injected into an HTML text context.
+ * Returns `undefined` when the input is `undefined` or `null` to preserve caller intent.
+ */
+export function escapeHTML(value) {
+    if (value === undefined || value === null) {
+        return value === null ? '' : undefined;
+    }
+    if (!HTML_ESCAPE_REGEX.test(value)) {
+        return value;
+    }
+    return value.replace(HTML_ESCAPE_REGEX, (char) => HTML_ESCAPE_LOOKUP[char]);
+}
+const RICH_TEXT_ALLOWED_TAGS = [
+    'a',
+    'abbr',
+    'b',
+    'blockquote',
+    'br',
+    'caption',
+    'code',
+    'div',
+    'em',
+    'strong',
+    'i',
+    'img',
+    'figure',
+    'figcaption',
+    'hr',
+    'li',
+    'ol',
+    'p',
+    'pre',
+    'span',
+    'sub',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'tfoot',
+    'th',
+    'thead',
+    'tr',
+    'u',
+    'ul',
+];
+const RICH_TEXT_ALLOWED_ATTR = [
+    'align',
+    'alt',
+    'class',
+    'data*',
+    'height',
+    'href',
+    'id',
+    'name',
+    'rel',
+    'src',
+    'style',
+    'target',
+    'title',
+    'width',
+];
+const RICH_TEXT_URI_REGEXP = /^(?:(?:https?|mailto|tel|ftp|file):|data:image\/[a-z0-9.+-]+;base64,)/i;
+const RICH_TEXT_SANITIZE_CONFIG = {
+    ALLOWED_TAGS: [...RICH_TEXT_ALLOWED_TAGS],
+    ALLOWED_ATTR: [...RICH_TEXT_ALLOWED_ATTR],
+    ALLOW_DATA_ATTR: true,
+    ALLOWED_URI_REGEXP: RICH_TEXT_URI_REGEXP,
+    FORBID_TAGS: ['style', 'script'],
+};
+/**
+ * Sanitize rich-text/HTML content using DOMPurify with a restrictive allow-list.
+ * Always returns a string (empty string when value is undefined or null).
+ */
+export function sanitizeRichText(value) {
+    if (value === undefined || value === null || value.trim().length === 0) {
+        return '';
+    }
+    return DOMPurify.sanitize(value, RICH_TEXT_SANITIZE_CONFIG);
+}