myaidev-method 0.2.18 → 0.2.22

package/src/lib/payloadcms-utils.js

@@ -144,7 +144,7 @@ export class PayloadCMSUtils {
 
         case 'list':
           return {
-            type: token.ordered ? 'number' : 'bullet',
+            type: 'list',
             listType: token.ordered ? 'number' : 'bullet',
             start: token.start || 1,
             tag: token.ordered ? 'ol' : 'ul',
@@ -213,7 +213,10 @@ export class PayloadCMSUtils {
       }
     };
 
-    const children = tokens.map(convertToken);
+    // Filter out space tokens and convert remaining tokens
+    const children = tokens
+      .filter(token => token.type !== 'space')
+      .map(convertToken);
 
     return {
       root: {
@@ -229,24 +232,353 @@ export class PayloadCMSUtils {
 
   /**
    * Parse inline text with formatting (bold, italic, code, links)
+   * Supports markdown formatters and converts to Lexical format codes:
+   * - **bold** → format: 1
+   * - *italic* → format: 2
+   * - `code` → format: 16
+   * - ***bold+italic*** → format: 3
    */
   parseInlineText(text) {
-    // Simple inline parser for bold, italic, code, links
     const children = [];
 
-    // For now, return simple text node
-    // TODO: Enhance with full inline formatting support
-    children.push({
+    // Strip HTML tags first
+    text = text.replace(/<[^>]+>/g, '');
+
+    // Parse markdown inline formatting using marked's inline lexer
+    try {
+      const tokens = marked.lexer(text);
+
+      // Extract inline tokens from paragraph if present
+      let inlineTokens = [];
+      if (tokens[0]?.type === 'paragraph' && tokens[0].tokens) {
+        inlineTokens = tokens[0].tokens;
+      } else if (tokens[0]?.tokens) {
+        inlineTokens = tokens[0].tokens;
+      } else {
+        // No inline tokens, return plain text
+        return [{
+          type: 'text',
+          text: text,
+          format: 0,
+          mode: 'normal',
+          style: '',
+          detail: 0,
+          version: 1
+        }];
+      }
+
+      // Convert each inline token to Lexical format
+      for (const token of inlineTokens) {
+        switch (token.type) {
+          case 'text':
+            children.push({
+              type: 'text',
+              text: token.text,
+              format: 0,
+              mode: 'normal',
+              style: '',
+              detail: 0,
+              version: 1
+            });
+            break;
+
+          case 'strong':
+            children.push({
+              type: 'text',
+              text: token.text,
+              format: 1, // IS_BOLD
+              mode: 'normal',
+              style: '',
+              detail: 0,
+              version: 1
+            });
+            break;
+
+          case 'em':
+            children.push({
+              type: 'text',
+              text: token.text,
+              format: 2, // IS_ITALIC
+              mode: 'normal',
+              style: '',
+              detail: 0,
+              version: 1
+            });
+            break;
+
+          case 'codespan':
+            children.push({
+              type: 'text',
+              text: token.text,
+              format: 16, // IS_CODE
+              mode: 'normal',
+              style: '',
+              detail: 0,
+              version: 1
+            });
+            break;
+
+          case 'link':
+            children.push({
+              type: 'link',
+              url: token.href,
+              children: [{
+                type: 'text',
+                text: token.text,
+                format: 0,
+                mode: 'normal',
+                style: '',
+                detail: 0,
+                version: 1
+              }],
+              direction: 'ltr',
+              format: '',
+              indent: 0,
+              version: 3
+            });
+            break;
+
+          default:
+            // Fallback for any unhandled token types
+            children.push({
+              type: 'text',
+              text: token.raw || token.text || '',
+              format: 0,
+              mode: 'normal',
+              style: '',
+              detail: 0,
+              version: 1
+            });
+        }
+      }
+    } catch (error) {
+      // If parsing fails, return plain text
+      children.push({
+        type: 'text',
+        text: text,
+        format: 0,
+        mode: 'normal',
+        style: '',
+        detail: 0,
+        version: 1
+      });
+    }
+
+    return children.length > 0 ? children : [{
       type: 'text',
-      text: text.replace(/<[^>]+>/g, ''), // Strip HTML tags
+      text: text,
       format: 0,
       mode: 'normal',
       style: '',
       detail: 0,
       version: 1
+    }];
+  }
+
+  /**
+   * Validate Lexical JSON structure
+   * Ensures output matches PayloadCMS Lexical editor format
+   * @param {Object} lexicalJSON - The Lexical JSON to validate
+   * @param {Object} options - Validation options
+   * @returns {Object} Validation result with errors array
+   */
+  validateLexicalStructure(lexicalJSON, options = {}) {
+    const errors = [];
+    const warnings = [];
+
+    // Check root structure
+    if (!lexicalJSON || typeof lexicalJSON !== 'object') {
+      errors.push('Lexical JSON must be an object');
+      return { valid: false, errors, warnings };
+    }
+
+    if (!lexicalJSON.root) {
+      errors.push('Missing root node');
+      return { valid: false, errors, warnings };
+    }
+
+    const root = lexicalJSON.root;
+
+    // Validate root node
+    if (root.type !== 'root') {
+      errors.push(`Root type must be 'root', got '${root.type}'`);
+    }
+
+    if (!Array.isArray(root.children)) {
+      errors.push('Root must have children array');
+      return { valid: false, errors, warnings };
+    }
+
+    // Validate each child node
+    const validateNode = (node, path = 'root') => {
+      if (!node || typeof node !== 'object') {
+        errors.push(`${path}: Node must be an object`);
+        return;
+      }
+
+      if (!node.type) {
+        errors.push(`${path}: Node missing type property`);
+        return;
+      }
+
+      // Validate based on node type
+      switch (node.type) {
+        case 'heading':
+          if (!node.tag || !/^h[1-6]$/.test(node.tag)) {
+            errors.push(`${path}: Heading must have tag h1-h6, got '${node.tag}'`);
+          }
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Heading must have children array`);
+          }
+          break;
+
+        case 'paragraph':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Paragraph must have children array`);
+          }
+          break;
+
+        case 'list':
+          if (!['bullet', 'number', 'check'].includes(node.listType)) {
+            errors.push(`${path}: List listType must be bullet/number/check, got '${node.listType}'`);
+          }
+          if (!['ul', 'ol'].includes(node.tag)) {
+            errors.push(`${path}: List tag must be ul/ol, got '${node.tag}'`);
+          }
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: List must have children array`);
+          }
+          // Validate list items
+          node.children?.forEach((item, i) => {
+            if (item.type !== 'listitem') {
+              errors.push(`${path}.children[${i}]: List child must be listitem, got '${item.type}'`);
+            }
+          });
+          break;
+
+        case 'listitem':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Listitem must have children array`);
+          }
+          break;
+
+        case 'text':
+          if (typeof node.text !== 'string') {
+            errors.push(`${path}: Text node must have string text property`);
+          }
+          if (typeof node.format !== 'number') {
+            errors.push(`${path}: Text node format must be number, got ${typeof node.format}`);
+          }
+          // Validate format is valid bitwise combination
+          if (node.format !== 0 && options.strictFormat) {
+            const validFormats = [1, 2, 3, 4, 8, 16, 32, 64, 128];
+            const isValidCombination = (format) => {
+              // Check if format is valid bitwise combination of base values
+              return format <= 255 && (format & ~255) === 0;
+            };
+            if (!isValidCombination(node.format)) {
+              warnings.push(`${path}: Unusual format value ${node.format}, expected bitwise combination`);
+            }
+          }
+          break;
+
+        case 'link':
+          if (typeof node.url !== 'string') {
+            errors.push(`${path}: Link must have string url property`);
+          }
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Link must have children array`);
+          }
+          break;
+
+        case 'code':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Code must have children array`);
+          }
+          break;
+
+        case 'quote':
+          if (!Array.isArray(node.children)) {
+            errors.push(`${path}: Quote must have children array`);
+          }
+          break;
+
+        case 'horizontalrule':
+          // HR nodes don't have children
+          break;
+
+        default:
+          if (options.strict) {
+            warnings.push(`${path}: Unknown node type '${node.type}'`);
+          }
+      }
+
+      // Recursively validate children
+      if (Array.isArray(node.children)) {
+        node.children.forEach((child, i) => {
+          validateNode(child, `${path}.children[${i}]`);
+        });
+      }
+    };
+
+    // Validate all root children
+    root.children.forEach((child, i) => {
+      validateNode(child, `root.children[${i}]`);
     });
 
-    return children;
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  /**
+   * Validate and optionally fix Lexical format codes
+   * Ensures format codes follow Lexical bitwise specification
+   * @param {number} format - The format code to validate
+   * @returns {Object} Validation result
+   */
+  validateFormatCode(format) {
+    const VALID_FORMATS = {
+      BOLD: 1,            // 1 << 0
+      ITALIC: 2,          // 1 << 1
+      STRIKETHROUGH: 4,   // 1 << 2
+      UNDERLINE: 8,       // 1 << 3
+      CODE: 16,           // 1 << 4
+      SUBSCRIPT: 32,      // 1 << 5
+      SUPERSCRIPT: 64,    // 1 << 6
+      HIGHLIGHT: 128      // 1 << 7
+    };
+
+    if (typeof format !== 'number') {
+      return {
+        valid: false,
+        error: `Format must be number, got ${typeof format}`
+      };
+    }
+
+    if (format < 0 || format > 255) {
+      return {
+        valid: false,
+        error: `Format must be between 0 and 255, got ${format}`
+      };
+    }
+
+    // Decompose format into individual flags
+    const flags = [];
+    Object.entries(VALID_FORMATS).forEach(([name, value]) => {
+      if ((format & value) === value) {
+        flags.push(name);
+      }
+    });
+
+    return {
+      valid: true,
+      format,
+      flags,
+      description: flags.length > 0 ? flags.join(' + ') : 'Plain text'
+    };
   }
 
   /**
@@ -372,11 +704,12 @@ export class PayloadCMSUtils {
   }
 
   /**
-   * Health check
+   * Health check - verifies PayloadCMS connectivity and database access
+   * Uses /api/posts endpoint to verify both API and database are accessible
    */
   async healthCheck() {
     try {
-      const response = await fetch(`${this.url}/api`);
+      const response = await fetch(`${this.url}/api/posts?limit=1`);
       return response.ok;
     } catch (error) {
       return false;