@antscorp/antsomi-ui 2.0.110 → 2.0.112

package/es/components/organism/TextEditor/extensions/UnorderedList.d.ts

@@ -0,0 +1,55 @@
+import { Node } from '@tiptap/core';
+import { type UnorderedListStyleType } from '../types';
+type ListStyleType = UnorderedListStyleType;
+export interface CustomUnorderedListOptions {
+    /**
+     * The node name for the list items
+     * @default 'listItem'
+     */
+    itemTypeName: string;
+    /**
+     * HTML attributes to add to the unordered list element
+     * @default {}
+     */
+    HTMLAttributes: Record<string, any>;
+    /**
+     * Keep the marks when splitting the list
+     * @default false
+     */
+    keepMarks: boolean;
+    /**
+     * Keep the attributes when splitting the list
+     * @default false
+     */
+    keepAttributes: boolean;
+    /**
+     * Default list style type
+     * @default 'disc'
+     */
+    defaultListStyleType: ListStyleType;
+}
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        customUnorderedList: {
+            /**
+             * Toggle a custom unordered list
+             */
+            toggleCustomUnorderedList: (options?: {
+                listStyleType?: ListStyleType;
+                customBulletChar?: string;
+            }) => ReturnType;
+            /**
+             * Set list style type for current unordered list
+             */
+            setUnorderedListStyle: (options: {
+                listStyleType?: ListStyleType;
+                customBulletChar?: string;
+            }) => ReturnType;
+        };
+    }
+}
+/**
+ * This extension allows you to create unordered lists with custom bullet styles.
+ */
+export declare const CustomUnorderedList: Node<CustomUnorderedListOptions, any>;
+export {};

package/es/components/organism/TextEditor/extensions/UnorderedList.js

@@ -0,0 +1,176 @@
+import { mergeAttributes, Node, wrappingInputRule } from '@tiptap/core';
+import { UNORDERED_LIST_STYLE_TYPE } from '../constants';
+const ListItemName = 'listItem';
+const TextStyleName = 'textStyle';
+/**
+ * Input regex patterns for different bullet styles
+ */
+const inputRegexPatterns = {
+    disc: /^\s*([-*•])\s$/,
+    circle: /^\s*([○◯])\s$/,
+    square: /^\s*([▪■])\s$/,
+    plus: /^\s*([+])\s$/,
+    arrow: /^\s*([→➤])\s$/,
+    star: /^\s*([★☆])\s$/,
+};
+/**
+ * Map input characters to bullet style types
+ */
+const charToBulletStyle = {
+    '-': UNORDERED_LIST_STYLE_TYPE.disc,
+    '*': UNORDERED_LIST_STYLE_TYPE.disc,
+    '•': UNORDERED_LIST_STYLE_TYPE.disc,
+    '○': UNORDERED_LIST_STYLE_TYPE.circle,
+    '◯': UNORDERED_LIST_STYLE_TYPE.circle,
+    '▪': UNORDERED_LIST_STYLE_TYPE.square,
+    '■': UNORDERED_LIST_STYLE_TYPE.square,
+    '+': UNORDERED_LIST_STYLE_TYPE.custom,
+    '→': UNORDERED_LIST_STYLE_TYPE.custom,
+    '➤': UNORDERED_LIST_STYLE_TYPE.custom,
+    '★': UNORDERED_LIST_STYLE_TYPE.custom,
+    '☆': UNORDERED_LIST_STYLE_TYPE.custom,
+};
+/**
+ * This extension allows you to create unordered lists with custom bullet styles.
+ */
+export const CustomUnorderedList = Node.create({
+    name: 'customUnorderedList',
+    addOptions() {
+        return {
+            itemTypeName: ListItemName,
+            HTMLAttributes: {
+                style: 'margin:0.5em 0;padding-inline-start:1.2em',
+            },
+            keepMarks: false,
+            keepAttributes: false,
+            defaultListStyleType: UNORDERED_LIST_STYLE_TYPE.disc,
+            customBulletChar: '→',
+        };
+    },
+    group: 'block list',
+    content() {
+        return `${this.options.itemTypeName}+`;
+    },
+    addAttributes() {
+        return {
+            listStyleType: {
+                default: this.options.defaultListStyleType,
+                parseHTML: element => {
+                    if (element.dataset.bulletChar) {
+                        return UNORDERED_LIST_STYLE_TYPE.custom;
+                    }
+                    const style = element.getAttribute('style');
+                    const listStyleType = style?.match(/list-style-type:\s*([^;]+)/)?.[1]?.trim();
+                    return listStyleType || this.options.defaultListStyleType;
+                },
+                renderHTML: attributes => {
+                    if (attributes.listStyleType === UNORDERED_LIST_STYLE_TYPE.custom) {
+                        return {};
+                    }
+                    return {
+                        style: `list-style-type: ${attributes.listStyleType}`,
+                    };
+                },
+            },
+            customBulletChar: {
+                default: null,
+                parseHTML: element => element.getAttribute('data-bullet-char'),
+                renderHTML: attributes => {
+                    if (attributes.listStyleType === UNORDERED_LIST_STYLE_TYPE.custom) {
+                        return {
+                            'data-bullet-char': attributes.customBulletChar,
+                            style: `list-style-type: '${attributes.customBulletChar} '`,
+                        };
+                    }
+                    return {};
+                },
+            },
+        };
+    },
+    parseHTML() {
+        return [{ tag: 'ul' }];
+    },
+    renderHTML({ HTMLAttributes }) {
+        return ['ul', mergeAttributes(this.options.HTMLAttributes, HTMLAttributes), 0];
+    },
+    addCommands() {
+        return {
+            toggleCustomUnorderedList: (options = {}) => ({ chain }) => {
+                const { listStyleType = this.options.defaultListStyleType, customBulletChar } = options;
+                if (this.options.keepAttributes) {
+                    return chain()
+                        .toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+                        .updateAttributes(ListItemName, this.editor.getAttributes(TextStyleName))
+                        .updateAttributes(this.name, {
+                        listStyleType,
+                        customBulletChar,
+                    })
+                        .run();
+                }
+                return chain()
+                    .toggleList(this.name, this.options.itemTypeName, this.options.keepMarks)
+                    .updateAttributes(this.name, {
+                    listStyleType,
+                    customBulletChar,
+                })
+                    .run();
+            },
+            setUnorderedListStyle: (options = {}) => ({ commands }) => {
+                const { listStyleType, customBulletChar } = options;
+                return commands.updateAttributes(this.name, {
+                    listStyleType,
+                    customBulletChar,
+                });
+            },
+        };
+    },
+    addKeyboardShortcuts() {
+        return {
+            'Mod-Shift-8': () => this.editor.commands.toggleCustomUnorderedList(),
+        };
+    },
+    addInputRules() {
+        const inputRules = [];
+        Object.values(inputRegexPatterns).forEach(regex => {
+            let inputRule = wrappingInputRule({
+                find: regex,
+                type: this.type,
+                getAttributes: match => {
+                    const char = match[1];
+                    const listStyleType = charToBulletStyle[char] || UNORDERED_LIST_STYLE_TYPE.disc;
+                    if (listStyleType === UNORDERED_LIST_STYLE_TYPE.custom) {
+                        return {
+                            listStyleType: UNORDERED_LIST_STYLE_TYPE.custom,
+                            customBulletChar: char,
+                        };
+                    }
+                    return { listStyleType };
+                },
+            });
+            if (this.options.keepMarks || this.options.keepAttributes) {
+                inputRule = wrappingInputRule({
+                    find: regex,
+                    type: this.type,
+                    keepMarks: this.options.keepMarks,
+                    keepAttributes: this.options.keepAttributes,
+                    getAttributes: match => {
+                        const char = match[1];
+                        const listStyleType = charToBulletStyle[char] || UNORDERED_LIST_STYLE_TYPE.disc;
+                        const baseAttributes = this.editor.getAttributes(TextStyleName);
+                        if (listStyleType === UNORDERED_LIST_STYLE_TYPE.custom) {
+                            return {
+                                ...baseAttributes,
+                                listStyleType: UNORDERED_LIST_STYLE_TYPE.custom,
+                                customBulletChar: char,
+                            };
+                        }
+                        return { ...baseAttributes, listStyleType };
+                    },
+                    editor: this.editor,
+                });
+            }
+            inputRules.push(inputRule);
+        });
+        return inputRules;
+    },
+});

package/es/components/organism/TextEditor/hooks/index.d.ts

@@ -0,0 +1,6 @@
+export * from './usePersistence';
+export * from './useMarkTracking';
+export * from './useStyleMemory';
+export * from './useStylePresets';
+export * from './useDocumentState';
+export * from './useColorSet';

package/es/components/organism/TextEditor/hooks/index.js

@@ -0,0 +1,6 @@
+export * from './usePersistence';
+export * from './useMarkTracking';
+export * from './useStyleMemory';
+export * from './useStylePresets';
+export * from './useDocumentState';
+export * from './useColorSet';

package/es/components/organism/TextEditor/hooks/useColorSet.d.ts

@@ -0,0 +1,4 @@
+export declare const useColorSet: () => {
+    colors: string[];
+    setColors: (newColors: string[]) => void;
+};

package/es/components/organism/TextEditor/hooks/useColorSet.js

@@ -0,0 +1,29 @@
+import { useBroadcastedLocalStorage, useDeepCompareEffect } from '@antscorp/antsomi-ui/es/hooks';
+import { useTextEditorStore } from '../provider';
+import { ANTSOMI_COMPONENT_PREFIX_CLS } from '@antscorp/antsomi-ui/es/constants';
+import { useCallback } from 'react';
+import isEqual from 'react-fast-compare';
+export const useColorSet = () => {
+    const colors = useTextEditorStore(s => s.colors);
+    const setColors = useTextEditorStore(s => s.setColors);
+    const { value: storageColors, setValue: setStorageColors } = useBroadcastedLocalStorage(`${ANTSOMI_COMPONENT_PREFIX_CLS}_text-editor`, undefined);
+    useDeepCompareEffect(() => {
+        if (storageColors === undefined && colors !== undefined) {
+            setStorageColors(colors);
+            return;
+        }
+        if (colors === undefined && storageColors !== undefined) {
+            setColors(storageColors);
+            return;
+        }
+        // Sync store → localStorage when both defined but different
+        if (colors !== undefined && storageColors !== undefined && !isEqual(colors, storageColors)) {
+            setStorageColors(colors);
+        }
+    }, [colors, storageColors, setColors, setStorageColors]);
+    const composeSetColors = useCallback((newColors) => {
+        setColors(newColors);
+        setStorageColors(newColors);
+    }, [setColors, setStorageColors]);
+    return { colors: colors || [], setColors: composeSetColors };
+};

package/es/components/organism/TextEditor/hooks/useDocumentState.d.ts

@@ -0,0 +1,18 @@
+import { Editor } from '@tiptap/react';
+import { DocumentStateConfig, getDocumentStats } from '../utils/documentState';
+export interface UseDocumentStateOptions extends DocumentStateConfig {
+    /** Callback when document becomes empty */
+    onBecomeEmpty?: () => void;
+    /** Callback when document becomes non-empty */
+    onBecomeNonEmpty?: () => void;
+    /** Callback when document state changes */
+    onStateChange?: (stats: ReturnType<typeof getDocumentStats>) => void;
+}
+export declare function useDocumentState(editor: Editor | null, options?: UseDocumentStateOptions): {
+    nodeSize: number;
+    textLength: number;
+    trimmedTextLength: number;
+    nodeCount: void;
+    isEmpty: boolean;
+    emptyDocumentSize: number;
+} | null;

package/es/components/organism/TextEditor/hooks/useDocumentState.js

@@ -0,0 +1,42 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { DocumentStateTracker, getDocumentStats, } from '../utils/documentState';
+export function useDocumentState(editor, options = {}) {
+    const { onBecomeEmpty, onBecomeNonEmpty, onStateChange } = options;
+    const [documentStats, setDocumentStats] = useState(() => editor ? getDocumentStats(editor.state) : null);
+    const trackerRef = useRef(new DocumentStateTracker());
+    const updateDocumentState = useCallback(() => {
+        if (!editor)
+            return;
+        const stats = getDocumentStats(editor.state);
+        const changes = trackerRef.current.update(editor.state);
+        setDocumentStats(stats);
+        // Trigger callbacks
+        if (changes.becameEmpty) {
+            onBecomeEmpty?.();
+        }
+        if (changes.becameNonEmpty) {
+            onBecomeNonEmpty?.();
+        }
+        if (changes.sizeChanged || changes.textLengthChanged) {
+            onStateChange?.(stats);
+        }
+    }, [editor, onBecomeEmpty, onBecomeNonEmpty, onStateChange]);
+    useEffect(() => {
+        if (!editor)
+            return;
+        // Initial state
+        updateDocumentState();
+        // Listen to changes
+        editor.on('update', updateDocumentState);
+        editor.on('transaction', updateDocumentState);
+        return () => {
+            editor.off('update', updateDocumentState);
+            editor.off('transaction', updateDocumentState);
+        };
+    }, [editor, updateDocumentState]);
+    // Reset tracker when editor changes
+    useEffect(() => {
+        trackerRef.current.reset();
+    }, [editor]);
+    return documentStats;
+}

package/es/components/organism/TextEditor/hooks/useMarkTracking.d.ts

@@ -0,0 +1,26 @@
+import { Editor } from '@tiptap/react';
+import { Mark } from '@tiptap/pm/model';
+export interface MarkSnapshot {
+    marks: Mark[];
+    position: number;
+    timestamp: number;
+    textContent: string;
+}
+export interface UseMarkTrackingOptions {
+    /** Maximum number of snapshots to keep */
+    maxSnapshots?: number;
+    /** Marks to exclude from tracking */
+    excludeMarks?: string[];
+    /** Debounce delay for tracking (ms) */
+    debounceDelay?: number;
+    /** Auto-capture snapshots */
+    autoCapture?: boolean;
+}
+export declare function useMarkTracking(editor: Editor | null, options?: UseMarkTrackingOptions): {
+    snapshots: MarkSnapshot[];
+    currentMarks: Mark[];
+    captureMarkSnapshot: () => void;
+    applySnapshot: (index: number) => void;
+    getSimilarSnapshots: (targetMarks?: Mark[]) => MarkSnapshot[];
+    clearSnapshots: () => void;
+};

package/es/components/organism/TextEditor/hooks/useMarkTracking.js

@@ -0,0 +1,69 @@
+import { useCallback, useEffect, useState } from 'react';
+import { textBetween } from '../utils';
+export function useMarkTracking(editor, options = {}) {
+    const { maxSnapshots = 10, excludeMarks = ['link', 'smartTag'], debounceDelay = 500, autoCapture = true, } = options;
+    const [snapshots, setSnapshots] = useState([]);
+    const [currentMarks, setCurrentMarks] = useState([]);
+    // Capture current mark state
+    const captureMarkSnapshot = useCallback(() => {
+        if (!editor)
+            return;
+        const { selection, storedMarks } = editor.state;
+        const { $from } = selection;
+        const marks = (storedMarks || $from.marks()).filter(mark => !excludeMarks.includes(mark.type.name));
+        const snapshot = {
+            marks,
+            position: $from.pos,
+            timestamp: Date.now(),
+            textContent: textBetween(editor.state, Math.max(0, $from.pos - 50), Math.min(editor.state.doc.content.size, $from.pos + 50)),
+        };
+        setSnapshots(prev => {
+            const updated = [snapshot, ...prev];
+            return updated.slice(0, maxSnapshots);
+        });
+        setCurrentMarks(marks);
+    }, [editor, excludeMarks, maxSnapshots]);
+    // Apply marks from snapshot
+    const applySnapshot = useCallback((index) => {
+        if (!editor || !snapshots[index])
+            return;
+        const snapshot = snapshots[index];
+        // Clear current marks
+        editor.chain().unsetAllMarks().run();
+        // Apply snapshot marks
+        snapshot.marks.forEach(mark => {
+            editor.chain().setMark(mark.type.name, mark.attrs).run();
+        });
+    }, [editor, snapshots]);
+    // Get similar snapshots based on marks
+    const getSimilarSnapshots = useCallback((targetMarks = currentMarks) => snapshots.filter(snapshot => {
+        const markNames = snapshot.marks.map(m => m.type.name).sort();
+        const targetNames = targetMarks.map(m => m.type.name).sort();
+        return JSON.stringify(markNames) === JSON.stringify(targetNames);
+    }), [snapshots, currentMarks]);
+    // Auto-capture setup
+    useEffect(() => {
+        if (!editor || !autoCapture)
+            return;
+        let timeoutId;
+        const handleUpdate = () => {
+            clearTimeout(timeoutId);
+            timeoutId = setTimeout(captureMarkSnapshot, debounceDelay);
+        };
+        editor.on('selectionUpdate', handleUpdate);
+        editor.on('update', handleUpdate);
+        return () => {
+            clearTimeout(timeoutId);
+            editor.off('selectionUpdate', handleUpdate);
+            editor.off('update', handleUpdate);
+        };
+    }, [editor, autoCapture, debounceDelay, captureMarkSnapshot]);
+    return {
+        snapshots,
+        currentMarks,
+        captureMarkSnapshot,
+        applySnapshot,
+        getSimilarSnapshots,
+        clearSnapshots: () => setSnapshots([]),
+    };
+}

package/es/components/organism/TextEditor/hooks/usePersistence.d.ts

@@ -0,0 +1,31 @@
+import { Editor } from '@tiptap/react';
+export interface PersistenceConfig {
+    /** Storage key */
+    key: string;
+    /** Storage type */
+    storage?: 'localStorage' | 'sessionStorage' | 'indexedDB';
+    /** Auto-save delay */
+    autoSaveDelay?: number;
+    /** Version for data migration */
+    version?: number;
+    /** Compression */
+    compress?: boolean;
+    /** Encryption key */
+    encryptionKey?: string;
+}
+export interface PersistentData {
+    content: string;
+    marks: any[];
+    metadata: {
+        timestamp: number;
+        version: number;
+        wordCount: number;
+        characterCount: number;
+    };
+}
+export declare function usePersistence(editor: Editor | null, config: PersistenceConfig): {
+    save: () => Promise<void>;
+    load: () => Promise<boolean>;
+    saveToStorage: (data: PersistentData) => Promise<void>;
+    loadFromStorage: () => Promise<PersistentData | null>;
+};

package/es/components/organism/TextEditor/hooks/usePersistence.js

@@ -0,0 +1,169 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useDebouncedCallback } from 'use-debounce';
+// Helper functions (simplified implementations)
+async function compressString(str) {
+    // Implement compression logic
+    return str;
+}
+async function decompressString(str) {
+    // Implement decompression logic
+    return str;
+}
+async function encryptString(str, _key) {
+    // Implement encryption logic
+    return str;
+}
+async function decryptString(str, _key) {
+    // Implement decryption logic
+    return str;
+}
+async function saveToIndexedDB(_key, _data) {
+    // Implement IndexedDB save
+}
+async function loadFromIndexedDB(_key) {
+    // Implement IndexedDB load
+    return null;
+}
+function migrateData(data, _targetVersion) {
+    // Implement data migration logic
+    return data;
+}
+export function usePersistence(editor, config) {
+    const { key, storage = 'localStorage', autoSaveDelay = 2000, version = 1, compress = false, encryptionKey, } = config;
+    const lastSavedContent = useRef('');
+    // Storage operations
+    const saveToStorage = useCallback(async (data) => {
+        try {
+            let serializedData = JSON.stringify(data);
+            // Apply compression if enabled
+            if (compress && 'CompressionStream' in window) {
+                // Use browser compression API if available
+                serializedData = await compressString(serializedData);
+            }
+            // Apply encryption if key provided
+            if (encryptionKey) {
+                serializedData = await encryptString(serializedData, encryptionKey);
+            }
+            switch (storage) {
+                case 'localStorage':
+                    localStorage.setItem(key, serializedData);
+                    break;
+                case 'sessionStorage':
+                    sessionStorage.setItem(key, serializedData);
+                    break;
+                case 'indexedDB':
+                    await saveToIndexedDB(key, serializedData);
+                    break;
+                default:
+                    break;
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('Failed to save to storage:', error);
+        }
+    }, [key, storage, compress, encryptionKey]);
+    const loadFromStorage = useCallback(async () => {
+        try {
+            let serializedData = null;
+            switch (storage) {
+                case 'localStorage':
+                    serializedData = localStorage.getItem(key);
+                    break;
+                case 'sessionStorage':
+                    serializedData = sessionStorage.getItem(key);
+                    break;
+                case 'indexedDB':
+                    serializedData = await loadFromIndexedDB(key);
+                    break;
+                default:
+                    break;
+            }
+            if (!serializedData)
+                return null;
+            // Apply decryption if key provided
+            if (encryptionKey) {
+                serializedData = await decryptString(serializedData, encryptionKey);
+            }
+            // Apply decompression if enabled
+            if (compress && 'DecompressionStream' in window) {
+                serializedData = await decompressString(serializedData);
+            }
+            const data = JSON.parse(serializedData);
+            // Handle version migration
+            if (data.metadata.version !== version) {
+                return migrateData(data, version);
+            }
+            return data;
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('Failed to load from storage:', error);
+            return null;
+        }
+    }, [key, storage, compress, encryptionKey, version]);
+    // Auto-save debounced function
+    const debouncedSave = useDebouncedCallback(async () => {
+        if (!editor)
+            return;
+        const currentContent = editor.getHTML();
+        // Only save if content changed
+        if (currentContent === lastSavedContent.current)
+            return;
+        const { selection, storedMarks } = editor.state;
+        const marks = storedMarks || selection.$from.marks();
+        const data = {
+            content: currentContent,
+            marks: marks.map(mark => ({
+                type: mark.type.name,
+                attrs: mark.attrs,
+            })),
+            metadata: {
+                timestamp: Date.now(),
+                version,
+                wordCount: editor.state.doc.textContent.split(/\s+/).length,
+                characterCount: editor.state.doc.textContent.length,
+            },
+        };
+        await saveToStorage(data);
+        lastSavedContent.current = currentContent;
+    }, autoSaveDelay);
+    // Manual save
+    const save = useCallback(async () => {
+        debouncedSave.flush();
+    }, [debouncedSave]);
+    // Load data
+    const load = useCallback(async () => {
+        if (!editor)
+            return false;
+        const data = await loadFromStorage();
+        if (!data)
+            return false;
+        // Set content
+        editor.commands.setContent(data.content);
+        // Restore marks if available
+        if (data.marks.length > 0) {
+            data.marks.forEach(({ type, attrs }) => {
+                editor.commands.setMark(type, attrs);
+            });
+        }
+        lastSavedContent.current = data.content;
+        return true;
+    }, [editor, loadFromStorage]);
+    // Auto-save setup
+    useEffect(() => {
+        if (!editor)
+            return;
+        editor.on('update', debouncedSave);
+        return () => {
+            editor.off('update', debouncedSave);
+            debouncedSave.flush(); // Save any pending changes
+        };
+    }, [editor, debouncedSave]);
+    return {
+        save,
+        load,
+        saveToStorage,
+        loadFromStorage,
+    };
+}

package/es/components/organism/TextEditor/hooks/useStyleMemory.d.ts

@@ -0,0 +1,6 @@
+import { Editor } from '@tiptap/react';
+export declare function useStyleMemory(editor: Editor | null): {
+    storeCurrentMarks: () => void;
+    clearStoredMarks: () => void;
+    applyStoredMarks: () => void;
+};