rimecms 0.22.0 → 0.23.0

package/dist/core/operations/hooks/before-read/process-document-fields.server.js

@@ -10,6 +10,21 @@ export const processDocumentFields = Hooks.beforeRead(async (args) => {
     for (const [key, config] of Object.entries(configMap)) {
         let value = getValueAtPath(key, doc);
         let isEmpty;
+        if (config.access && config.access.read) {
+            const authorized = config.access.read(event.locals.user);
+            if (!authorized) {
+                doc = deleteValueAtPath(doc, key);
+                continue;
+            }
+        }
+        if (config.hooks?.beforeRead) {
+            if (value) {
+                for (const hook of config.hooks.beforeRead) {
+                    value = await hook(value, { event, config, operation: args.context, documentId: doc.id });
+                    doc = setValueAtPath(key, doc, value);
+                }
+            }
+        }
         try {
             isEmpty = config.isEmpty(value);
         }
@@ -41,22 +56,6 @@ export const processDocumentFields = Hooks.beforeRead(async (args) => {
                 doc = setValueAtPath(key, doc, withoutResidualBlock);
             }
         }
-        if (config.access && config.access.read) {
-            const authorized = config.access.read(event.locals.user);
-            if (!authorized) {
-                doc = deleteValueAtPath(doc, key);
-                continue;
-            }
-        }
-        if (config.hooks?.beforeRead) {
-            let value = getValueAtPath(key, doc);
-            if (value) {
-                for (const hook of config.hooks.beforeRead) {
-                    value = await hook(value, { event, config, operation: args.context, documentId: doc.id });
-                    doc = setValueAtPath(key, doc, value);
-                }
-            }
-        }
     }
     return { ...args, doc };
 });

package/dist/fields/email/index.js

@@ -1,4 +1,5 @@
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import { sanitize } from '../../util/string';
 import validate from '../../util/validate.js';
 import EmailComp from './component/Email.svelte';
 class EmailFieldBuilder extends FormFieldBuilder {
@@ -7,6 +8,9 @@ class EmailFieldBuilder extends FormFieldBuilder {
     constructor(name) {
         super(name, 'email');
         this.field.validate = validate.email;
+        this.field.hooks = {
+            beforeSave: [sanitize]
+        };
     }
     layout(layout) {
         this.field.layout = layout;

package/dist/fields/link/index.d.ts

@@ -11,6 +11,7 @@ export declare class LinkFieldBuilder extends FormFieldBuilder<LinkField> {
     layout(str: 'compact' | 'default'): this;
     defaultValue(value: Link | DefaultValueFn<Link>): this;
     types(...values: LinkType[]): this;
+    static readonly sanitize: (link: unknown) => unknown;
     compile(): {
         type: "link";
         live?: boolean | undefined;

package/dist/fields/link/index.js

@@ -1,4 +1,5 @@
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import { sanitize } from '../../util/string';
 import validate from '../../util/validate.js';
 import Cell from './component/Cell.svelte';
 import LinkComp from './component/Link.svelte';
@@ -11,9 +12,13 @@ export class LinkFieldBuilder extends FormFieldBuilder {
         this.field.validate = validate.link;
         this.field.layout = 'default';
         this.field.types = ['url'];
+        this.field.hooks = {
+            beforeSave: [LinkFieldBuilder.sanitize]
+        };
         if (import.meta.env.SSR && import.meta.url) {
             import('./index.server.js').then((module) => {
                 this.field.hooks = {
+                    ...this.field.hooks,
                     beforeRead: [module.populateRessourceURL]
                 };
             });
@@ -37,6 +42,20 @@ export class LinkFieldBuilder extends FormFieldBuilder {
         this.field.types = values;
         return this;
     }
+    static sanitize = (link) => {
+        if (!link)
+            return link;
+        const isLinkValue = (v) => typeof link === 'object' && !Array.isArray(link) && 'value' in link;
+        if (typeof link === 'string')
+            return sanitize(link);
+        if (isLinkValue(link) && link.value) {
+            return {
+                ...link,
+                url: link.url ? sanitize(link.url) : undefined,
+                value: sanitize(link.value)
+            };
+        }
+    };
     compile() {
         if (!this.field.defaultValue) {
             this.field.defaultValue = { value: '', target: '_self', type: this.field.types[0] };

package/dist/fields/rich-text/core/config-builders.js

@@ -5,6 +5,9 @@ import { ListItem } from '@tiptap/extension-list';
 import Text from '@tiptap/extension-text';
 import Typography from '@tiptap/extension-typography';
 import { Dropcursor, Gapcursor, Placeholder, UndoRedo } from '@tiptap/extensions';
+import { API_PROXY, getAPIProxyContext } from '../../../panel/context/api-proxy.svelte.js';
+import { CONFIG_CTX, getConfigContext } from '../../../panel/context/config.svelte.js';
+import { getUserContext, USER_CTX } from '../../../panel/context/user.svelte.js';
 import { hasSuggestion } from '../util.js';
 import { CurrentNodeAttribute } from './extensions/current-node/current-node.js';
 import { defaultFeatures } from './features/index.js';
@@ -50,8 +53,25 @@ export function buildEditorConfig(args) {
     // Add all feature extensions to the editor
     // We need to track which extensions we've already added to avoid duplicates
     const addedExtensions = new Set();
+    const hasExtension = (f) => !!f.extension;
     features.forEach((feature) => {
-        if (feature.extension && !addedExtensions.has(feature.extension)) {
+        if (hasExtension(feature) && !addedExtensions.has(feature.extension)) {
+            // Populate contexts
+            if ('addNodeView' in feature.extension.config) {
+                const originalAddOption = feature.extension.config.addOptions || (() => ({}));
+                const contexts = new Map();
+                const configContext = getConfigContext();
+                const apiProxyContext = getAPIProxyContext(API_PROXY.DOCUMENT);
+                const userContext = getUserContext();
+                contexts.set(CONFIG_CTX, configContext);
+                contexts.set(API_PROXY.DOCUMENT, apiProxyContext);
+                contexts.set(USER_CTX, userContext);
+                feature.extension.config.addOptions = () => {
+                    // @ts-expect-error
+                    return { ...originalAddOption(), contexts };
+                };
+            }
+            // Push extension
             baseEditorConfig.extensions?.push(feature.extension);
             addedExtensions.add(feature.extension);
         }

package/dist/fields/rich-text/core/features/fields/fields.svelte

@@ -46,7 +46,10 @@
 
 <NodeViewWrapper>
 	<FieldsPreviewTrigger class="rz-rich-text-fields-preview" onclick={() => (isSheetOpen = true)}>
-		<FieldsPreview fields={previewFields} getField={(field) => form.useField(field.name, field.raw)} />
+		<FieldsPreview
+			fields={previewFields}
+			getField={(field) => form.useField(field.name, field.raw)}
+		/>
 	</FieldsPreviewTrigger>
 </NodeViewWrapper>
 
@@ -54,7 +57,7 @@
 	<Sheet.Content side="right" class="rz-rich-text-sheet">
 		{#each previewFields || [] as field, index (index)}
 			{@const FieldComponent = field.component}
-			<FieldComponent config={field.raw} {form} />
+			<FieldComponent path={field.raw.name} config={field.raw} {form} />
 		{/each}
 	</Sheet.Content>
 </Sheet.Root>

package/dist/fields/rich-text/core/svelte/node-view-renderer.svelte.d.ts

@@ -19,6 +19,7 @@ export interface SvelteNodeViewRendererOptions extends NodeViewRendererOptions {
     update: ((props: RendererUpdateProps) => boolean) | null;
     as?: string;
     attrs?: AttrProps;
+    context?: Map<string, any>;
 }
 declare const SvelteNodeViewRenderer: (component: Component<NodeViewProps>, options?: Partial<SvelteNodeViewRendererOptions>) => NodeViewRenderer;
 export default SvelteNodeViewRenderer;

package/dist/fields/rich-text/core/svelte/node-view-renderer.svelte.js

@@ -24,7 +24,9 @@ class SvelteNodeView extends NodeView {
             updateAttributes: (attributes = {}) => this.updateAttributes(attributes),
             deleteNode: () => this.deleteNode()
         });
-        this.contentDOMElement = this.node.isLeaf ? null : document.createElement(this.node.isInline ? 'span' : 'div');
+        this.contentDOMElement = this.node.isLeaf
+            ? null
+            : document.createElement(this.node.isInline ? 'span' : 'div');
         if (this.contentDOMElement) {
             // For some reason the whiteSpace prop is not inherited properly in Chrome and Safari
             // With this fix it seems to work fine
@@ -35,6 +37,12 @@ class SvelteNodeView extends NodeView {
         context.set(TIPTAP_NODE_VIEW, {
             onDragStart: this.onDragStart.bind(this)
         });
+        if (this.extension.options.contexts) {
+            for (const [key, ctx] of this.extension.options.contexts.entries()) {
+                context.set(key, ctx);
+            }
+        }
+        console.log(context);
         const as = this.options.as ?? (this.node.isInline ? 'span' : 'div');
         const target = document.createElement(as);
         target.classList.add(`node-${this.node.type.name}`);
@@ -58,7 +66,9 @@ class SvelteNodeView extends NodeView {
     }
     appendContendDom() {
         const contentElement = this.dom.querySelector('[data-node-view-content]');
-        if (this.contentDOMElement && contentElement && !contentElement.contains(this.contentDOMElement)) {
+        if (this.contentDOMElement &&
+            contentElement &&
+            !contentElement.contains(this.contentDOMElement)) {
             contentElement.appendChild(this.contentDOMElement);
         }
     }
@@ -122,7 +132,9 @@ class SvelteNodeView extends NodeView {
         if (node.type !== this.node.type) {
             return false;
         }
-        if (node === this.node && this.decorations === decorations && this.innerDecorations === innerDecorations) {
+        if (node === this.node &&
+            this.decorations === decorations &&
+            this.innerDecorations === innerDecorations) {
             return true;
         }
         this.node = node;

package/dist/fields/rich-text/index.d.ts

@@ -24,6 +24,7 @@ export declare class RichTextFieldBuilder extends FormFieldBuilder<RichTextField
      */
     features(...features: Array<RichTextFeature>): this;
     static readonly jsonParse: (value: string) => string;
+    static readonly sanitize: (value: unknown) => any;
     static readonly stringify: (value: string) => string;
     defaultValue(value: RichTextContent | DefaultValueFn<RichTextContent>): this;
 }

package/dist/fields/rich-text/index.js

@@ -1,23 +1,19 @@
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
+import { sanitize } from '../../util/string.js';
 import Cell from './component/Cell.svelte';
 import RichText from './component/RichText.svelte';
+import { sanitizeJSONContent } from './sanitize';
 const isEmpty = (value) => {
-    const reduceText = (prev, curr) => {
-        if ('text' in curr) {
-            prev += curr.text;
-        }
-        else if ('content' in curr) {
-            return curr.content.reduce(reduceText, prev);
-        }
-        return prev;
-    };
-    return (typeof value === 'object' &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.getPrototypeOf(value) === Object.prototype &&
-        'content' in value &&
-        Array.isArray(value.content) &&
-        value.content.reduce(reduceText, '') === '');
+    if (!value)
+        return true;
+    // Check for content length in pm object
+    if (typeof value === 'object' && !Array.isArray(value) && 'content' in value) {
+        return Array.isArray(value.content) && value.content.length === 0;
+    }
+    // Allow simple string
+    if (typeof value === 'string' && !!value)
+        return false;
+    return true;
 };
 export class RichTextFieldBuilder extends FormFieldBuilder {
     //
@@ -27,7 +23,7 @@ export class RichTextFieldBuilder extends FormFieldBuilder {
         this.field.isEmpty = isEmpty;
         this.field.hooks = {
             beforeRead: [RichTextFieldBuilder.jsonParse],
-            beforeSave: [RichTextFieldBuilder.stringify],
+            beforeSave: [RichTextFieldBuilder.sanitize, RichTextFieldBuilder.stringify],
             beforeValidate: []
         };
     }
@@ -71,6 +67,19 @@ export class RichTextFieldBuilder extends FormFieldBuilder {
         }
         return value;
     };
+    static sanitize = (value) => {
+        if (!value)
+            return value;
+        // Handle string input - just sanitize as plain text
+        if (typeof value === 'string') {
+            return sanitize(value);
+        }
+        // Handle JSONContent object
+        if (typeof value === 'object' && value !== null && 'content' in value) {
+            return sanitizeJSONContent(value);
+        }
+        return value;
+    };
     static stringify = (value) => {
         if (typeof value === 'string')
             return value;

package/dist/fields/rich-text/sanitize.d.ts

@@ -0,0 +1 @@
+export declare const sanitizeJSONContent: (content: any) => any;

package/dist/fields/rich-text/sanitize.js

@@ -0,0 +1,25 @@
+import { sanitize } from '../../util/string.js';
+// Helper function to sanitize JSONContent recursively
+export const sanitizeJSONContent = (content) => {
+    if (!content)
+        return content;
+    // Handle text nodes - sanitize the text content
+    if (content.type === 'text' && content.text) {
+        return {
+            ...content,
+            text: sanitize(content.text)
+        };
+    }
+    // Skip sanitization for code blocks (preserve original content)
+    if (content.type === 'codeBlock' || content.type === 'code') {
+        return content;
+    }
+    // Recursively handle content array
+    if (content.content && Array.isArray(content.content)) {
+        return {
+            ...content,
+            content: content.content.map(sanitizeJSONContent)
+        };
+    }
+    return content;
+};

package/dist/fields/slug/index.d.ts

@@ -3,6 +3,7 @@ import type { DefaultValueFn, FormField } from '../types.js';
 export declare const slug: (name: string) => SlugFieldBuilder;
 export declare class SlugFieldBuilder extends FormFieldBuilder<SlugField> {
     _metaUrl: string;
+    constructor(name: string);
     get component(): import("svelte").Component<{
         path: string;
         config: SlugField;

package/dist/fields/slug/index.js

@@ -1,12 +1,20 @@
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
 import { validate } from '../../util/index.js';
-import { slugify } from '../../util/string.js';
+import { sanitize, slugify } from '../../util/string.js';
 import Cell from './component/Cell.svelte';
 import Slug from './component/Slug.svelte';
-export const slug = (name) => new SlugFieldBuilder(name, 'slug');
+export const slug = (name) => new SlugFieldBuilder(name);
 export class SlugFieldBuilder extends FormFieldBuilder {
     //
     _metaUrl = import.meta.url;
+    constructor(name) {
+        super(name, 'slug');
+        this.field.validate = validate.slug;
+        this.field.isEmpty = (value) => !value;
+        this.field.hooks = {
+            beforeSave: [sanitize]
+        };
+    }
     get component() {
         return Slug;
     }
@@ -38,15 +46,9 @@ export class SlugFieldBuilder extends FormFieldBuilder {
         return this;
     }
     compile() {
-        if (!this.field.validate) {
-            this.field.validate = validate.slug;
-        }
         if (!this.field.placeholder) {
             this.field.placeholder = slugify(this.field.label || this.field.name);
         }
-        if (!this.field.isEmpty) {
-            this.field.isEmpty = (value) => !value;
-        }
         return super.compile();
     }
 }

package/dist/fields/text/index.d.ts

@@ -3,6 +3,7 @@ import type { DefaultValueFn, FormField } from '../types.js';
 /****************************************************/
 export declare class TextFieldBuilder extends FormFieldBuilder<TextField> {
     _metaUrl: string;
+    constructor(name: string);
     unique(bool?: boolean): this;
     get component(): import("svelte").Component<import("./component/props").TextFieldProps, {}, "">;
     get cell(): null;

package/dist/fields/text/index.js

@@ -1,10 +1,16 @@
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
-import { capitalize } from '../../util/string.js';
+import { capitalize, sanitize } from '../../util/string.js';
 import Text from './component/Text.svelte';
 /****************************************************/
 export class TextFieldBuilder extends FormFieldBuilder {
     //
     _metaUrl = import.meta.url;
+    constructor(name) {
+        super(name, 'text');
+        this.field.hooks = {
+            beforeSave: [sanitize]
+        };
+    }
     unique(bool) {
         this.field.unique = typeof bool === 'boolean' ? bool : true;
         return this;
@@ -47,4 +53,4 @@ export class TextFieldBuilder extends FormFieldBuilder {
         return this;
     }
 }
-export const text = (name) => new TextFieldBuilder(name, 'text');
+export const text = (name) => new TextFieldBuilder(name);

package/dist/fields/textarea/index.d.ts

@@ -3,6 +3,7 @@ import type { DefaultValueFn, FormField } from '../types.js';
 export declare const textarea: (name: string) => TextAreaFieldBuilder;
 export declare class TextAreaFieldBuilder extends FormFieldBuilder<TextAreaField> {
     _metaUrl: string;
+    constructor(name: string);
     get component(): import("svelte").Component<import("./component/props").TextAreaFieldProps, {}, "">;
     get cell(): null;
     defaultValue(value: string | DefaultValueFn<string>): this;

package/dist/fields/textarea/index.js

@@ -1,10 +1,16 @@
 import { FormFieldBuilder } from '../../core/fields/builders/form-field-builder.js';
-import { capitalize } from '../../util/string.js';
+import { capitalize, sanitize } from '../../util/string.js';
 import TextArea from './component/TextArea.svelte';
-export const textarea = (name) => new TextAreaFieldBuilder(name, 'textarea');
+export const textarea = (name) => new TextAreaFieldBuilder(name);
 export class TextAreaFieldBuilder extends FormFieldBuilder {
     //
     _metaUrl = import.meta.url;
+    constructor(name) {
+        super(name, 'textarea');
+        this.field.hooks = {
+            beforeSave: [sanitize]
+        };
+    }
     get component() {
         return TextArea;
     }

package/dist/panel/context/api-proxy.svelte.d.ts

@@ -8,17 +8,17 @@ export type Resource<T = any> = {
 type GetResourcesOptions<T> = {
     transformData?: (input: any) => T;
 };
-export declare function setAPIProxyContext(key?: string): {
+export declare function setAPIProxyContext(key?: symbol): {
     getRessource: <T>(url: string, options?: GetResourcesOptions<T>) => Resource<T>;
     invalidateAll: () => void;
 };
-export declare function getAPIProxyContext(key?: string): {
+export declare function getAPIProxyContext(key?: symbol): {
     getRessource: <T>(url: string, options?: GetResourcesOptions<T>) => Resource<T>;
     invalidateAll: () => void;
 };
 export declare const API_PROXY: {
-    DOCUMENT: string;
-    ROOT: string;
-    TIPTAP: string;
+    DOCUMENT: symbol;
+    ROOT: symbol;
+    TIPTAP: symbol;
 };
 export {};

package/dist/panel/context/api-proxy.svelte.js

@@ -1,5 +1,4 @@
 import { getContext, setContext } from 'svelte';
-const API_PROXY_KEY = Symbol('api-proxy');
 function createAPIProxy() {
     // Use explicit type instead of ReturnType
     const resources = $state(new Map());
@@ -72,13 +71,14 @@ function createAPIProxy() {
 }
 export function setAPIProxyContext(key = API_PROXY.ROOT) {
     const apiProxy = createAPIProxy();
-    return setContext(`${API_PROXY_KEY.toString()}.${key}`, apiProxy);
+    return setContext(key, apiProxy);
 }
 export function getAPIProxyContext(key = API_PROXY.ROOT) {
-    return getContext(`${API_PROXY_KEY.toString()}.${key}`);
+    return getContext(key);
 }
+// @TODO why multiple APIProxy ROOT everywhere should work
 export const API_PROXY = {
-    DOCUMENT: 'document',
-    ROOT: 'root',
-    TIPTAP: 'tiptap'
+    DOCUMENT: Symbol('api-proxy.document'),
+    ROOT: Symbol('api-proxy.root'),
+    TIPTAP: Symbol('api-proxy.tiptap')
 };

package/dist/panel/context/config.svelte.d.ts

@@ -1,5 +1,6 @@
 import type { BuiltAreaClient, BuiltCollectionClient, BuiltConfigClient } from '../../core/config/types.js';
 import type { Prototype, PrototypeSlug } from '../../core/types/doc.js';
+export declare const CONFIG_CTX: unique symbol;
 export declare function setConfigContext(initial: BuiltConfigClient): {
     readonly raw: BuiltConfigClient;
     getArea: (slug: string) => BuiltAreaClient;

package/dist/panel/context/config.svelte.js

@@ -19,11 +19,11 @@ function createConfigStore(config) {
         getDocumentConfig
     };
 }
-const CONFIG_KEY = Symbol('rime.config');
+export const CONFIG_CTX = Symbol('rime.config');
 export function setConfigContext(initial) {
     const store = createConfigStore(initial);
-    return setContext(CONFIG_KEY, store);
+    return setContext(CONFIG_CTX, store);
 }
 export function getConfigContext() {
-    return getContext(CONFIG_KEY);
+    return getContext(CONFIG_CTX);
 }

package/dist/panel/context/form.svelte.d.ts

@@ -12,6 +12,7 @@ export declare function setFormContext(initial: Dic, key: string): {
     };
     readOnly: boolean;
     enhance: SubmitFunction;
+    getRawValue: <T>(path: string) => NonNullable<T> | null;
     readonly canSubmit: boolean;
     readonly errors: {
         readonly length: number;
@@ -50,6 +51,7 @@ export declare function getFormContext(key: string): {
     };
     readOnly: boolean;
     enhance: SubmitFunction;
+    getRawValue: <T>(path: string) => NonNullable<T> | null;
     readonly canSubmit: boolean;
     readonly errors: {
         readonly length: number;

package/dist/panel/context/form.svelte.js

@@ -1,4 +1,6 @@
 import { applyAction } from '$app/forms';
+import { getValueAtPath } from '../../util/object';
+import { snapshot } from '../../util/state';
 import { diff } from 'deep-object-diff';
 import { getContext, setContext } from 'svelte';
 import { setErrorsContext } from './errors.svelte';
@@ -15,6 +17,22 @@ function createFormStore(initial, key) {
             errors.value = {};
         }
     });
+    /**
+     * Function that return an unreactive snapshot of a value given a path.
+     *
+     * @param path Field path ex: blocks.0.title
+     * @returns an unreactive snapshot
+     *
+     * @example
+     * const form = getDocumentFormContext()
+     * const initialValue = form.getRawValue('blocks.0.title')
+     *
+     * // value will not update if doc.blocks.0.title update
+     */
+    function getRawValue(path) {
+        console.log(path);
+        return snapshot(getValueAtPath(path, form)) || null;
+    }
     function setValue(path, value) {
         status = undefined;
         form = { ...form, [path]: value };
@@ -104,6 +122,7 @@ function createFormStore(initial, key) {
         useField,
         readOnly: false,
         enhance,
+        getRawValue,
         get canSubmit() {
             return canSubmit;
         },

package/dist/panel/context/user.svelte.d.ts

@@ -1,4 +1,5 @@
 import type { User } from '../../core/collections/auth/types.js';
+export declare const USER_CTX: unique symbol;
 export declare function setUserContext(initial: User): {
     readonly attributes: User;
 };

package/dist/panel/context/user.svelte.js

@@ -7,11 +7,11 @@ function createUserStore(initial) {
         }
     };
 }
-const CONFIG_KEY = Symbol('rime.user');
+export const USER_CTX = Symbol('rime.user');
 export function setUserContext(initial) {
     const user = createUserStore(initial);
-    return setContext(CONFIG_KEY, user);
+    return setContext(USER_CTX, user);
 }
 export function getUserContext() {
-    return getContext(CONFIG_KEY);
+    return getContext(USER_CTX);
 }

package/dist/util/string.d.ts

@@ -92,3 +92,7 @@ export declare const isCamelCase: (str: string) => boolean;
  * isValidSlug("hello world");
  */
 export declare const isValidSlug: (str: string) => boolean;
+/**
+ * Sanitizing using DOMPurify
+ */
+export declare const sanitize: (value?: string) => string | undefined;

package/dist/util/string.js

@@ -1,4 +1,5 @@
 import camelCase from 'camelcase';
+import DOMPurify from 'isomorphic-dompurify';
 /**
  * Capitalizes the first letter of a string.
  *
@@ -161,3 +162,11 @@ export const isCamelCase = (str) => /^[a-z][a-zA-Z0-9]*$/.test(str);
  * isValidSlug("hello world");
  */
 export const isValidSlug = (str) => /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(str);
+/**
+ * Sanitizing using DOMPurify
+ */
+export const sanitize = (value) => {
+    if (!value)
+        return value;
+    return DOMPurify.sanitize(value);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rimecms",
-	"version": "0.22.0",
+	"version": "0.23.0",
 	"homepage": "https://github.com/bienbiendev/rime",
 	"scripts": {
 		"dev": "vite dev",
@@ -206,6 +206,7 @@
 		"dotenv": "^16.4.7",
 		"drizzle-orm": "^0.44.2",
 		"flat": "^6.0.1",
+		"isomorphic-dompurify": "^2.31.0",
 		"js-cookie": "^3.0.5",
 		"magic-string-ast": "^1.0.2",
 		"nodemailer": "^6.10.0",