@fc-components/monaco-editor 0.1.12 → 0.1.14

package/dist/monaco-editor.esm.js

@@ -2241,7 +2241,11 @@ function PromQLEditor(props) {
       },
       scrollBeyondLastLine: false,
       suggest: {
-        showWords: false
+        showWords: false,
+        // 防止补全层自动关闭的关键配置
+        filterGraceful: false,
+        snippetsPreventQuickSuggestions: false,
+        shareSuggestSelections: false
       },
       suggestFontSize: 12,
       wordWrap: 'on',
@@ -2251,5 +2255,922 @@ function PromQLEditor(props) {
   })));
 }
 
-export { PromQLEditor as PromQLMonacoEditor };
+var languageConfiguration$1 = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: '#'
+  },
+  brackets: [['{', '}'], ['[', ']']],
+  autoClosingPairs: [{
+    open: '{',
+    close: '}'
+  }, {
+    open: '[',
+    close: ']'
+  }, {
+    open: '"',
+    close: '"'
+  }, {
+    open: "'",
+    close: "'"
+  }],
+  surroundingPairs: [{
+    open: '{',
+    close: '}'
+  }, {
+    open: '[',
+    close: ']'
+  }, {
+    open: '"',
+    close: '"'
+  }, {
+    open: "'",
+    close: "'"
+  }],
+  folding: {
+    offSide: true
+  }
+};
+// YAML keywords
+var keywords$1 = ['true', 'false', 'null', 'True', 'False', 'Null', 'TRUE', 'FALSE', 'NULL', 'yes', 'no', 'Yes', 'No', 'YES', 'NO', 'on', 'off', 'On', 'Off', 'ON', 'OFF'];
+// YAML operators and special characters (for future use)
+// const operators = [':', '-', '|', '>', '&', '*', '!', '%', '@'];
+var language$1 = {
+  tokenPostfix: '.yaml',
+  brackets: [{
+    token: 'delimiter.bracket',
+    open: '{',
+    close: '}'
+  }, {
+    token: 'delimiter.square',
+    open: '[',
+    close: ']'
+  }],
+  keywords: keywords$1,
+  numberInteger: /(?:0|[+-]?[0-9]+)/,
+  numberFloat: /(?:0|[+-]?[0-9]+)(?:\.[0-9]+)?(?:e[-+][1-9][0-9]*)?/,
+  numberOctal: /0o[0-7]+/,
+  numberHex: /0x[0-9a-fA-F]+/,
+  numberInfinity: /[+-]?\.(?:inf|Inf|INF)/,
+  numberNaN: /\.(?:nan|Nan|NAN)/,
+  numberDate: /\d{4}-\d{2}-\d{2}(?:[Tt ]\d{1,2}:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d{1,2}(?::\d{2})?))?)?/,
+  escapes: /\\(?:[btnfr\\"']|[0-7][0-7]?|[0-3][0-7]{2})/,
+  tokenizer: {
+    root: [{
+      include: '@whitespace'
+    }, {
+      include: '@comment'
+    },
+    // Document markers
+    [/^---/, 'meta.document'], [/^\.{3}/, 'meta.document'],
+    // Keys (property names)
+    [/^(\s*)([^:\s]+)(\s*)(:)/, ['white', 'key', 'white', 'delimiter']], [/(\s*)([^:\s]+)(\s*)(:)/, ['white', 'key', 'white', 'delimiter']],
+    // Flow collections
+    [/\{/, '@brackets', '@flowMap'], [/\[/, '@brackets', '@flowSequence'],
+    // Block scalars
+    [/[|>][-+]?(\d+)?/, 'string.block', '@blockScalar'],
+    // Numbers
+    [/@numberInfinity/, 'number.infinity'], [/@numberNaN/, 'number.nan'], [/@numberDate/, 'number.date'], [/@numberHex/, 'number.hex'], [/@numberOctal/, 'number.octal'], [/@numberFloat/, 'number.float'], [/@numberInteger/, 'number'],
+    // Strings
+    [/"([^"\\]|\\.)*$/, 'string.invalid'], [/'([^'\\]|\\.)*$/, 'string.invalid'], [/"/, 'string', '@doubleQuotedString'], [/'/, 'string', '@singleQuotedString'],
+    // Anchors and aliases
+    [/&\w+/, 'tag.anchor'], [/\*\w+/, 'tag.alias'],
+    // Tags
+    [/![\w\-\/]+/, 'tag'],
+    // Keywords
+    [/[^\s\[\{\,]+/, {
+      cases: {
+        '@keywords': 'keyword',
+        '@default': 'string.unquoted'
+      }
+    }],
+    // List items
+    [/^(\s*)(-\s)/, ['white', 'delimiter']], [/(\s*)(-\s)/, ['white', 'delimiter']]],
+    whitespace: [[/[ \t\r\n]+/, 'white']],
+    comment: [[/#.*$/, 'comment']],
+    doubleQuotedString: [[/[^\\"]+/, 'string'], [/@escapes/, 'string.escape'], [/\\./, 'string.escape.invalid'], [/"/, 'string', '@pop']],
+    singleQuotedString: [[/[^\\']+/, 'string'], [/''/, 'string.escape'], [/'/, 'string', '@pop']],
+    blockScalar: [[/^(\s*).+$/, 'string.block'], [/^(?!\s)/, '', '@pop']],
+    flowMap: [{
+      include: '@whitespace'
+    }, {
+      include: '@comment'
+    }, [/\}/, '@brackets', '@pop'], [/,/, 'delimiter'], [/:/, 'delimiter'], [/"/, 'string', '@doubleQuotedString'], [/'/, 'string', '@singleQuotedString'], [/[^\s\,\}\:]+/, 'string.unquoted']],
+    flowSequence: [{
+      include: '@whitespace'
+    }, {
+      include: '@comment'
+    }, [/\]/, '@brackets', '@pop'], [/,/, 'delimiter'], [/"/, 'string', '@doubleQuotedString'], [/'/, 'string', '@singleQuotedString'], [/[^\s\,\]]+/, 'string.unquoted']]
+  }
+};
+
+function getMonacoCompletionItemKind$1(type, monaco) {
+  switch (type) {
+    case 'KEYWORD':
+      return monaco.languages.CompletionItemKind.Keyword;
+    case 'VALUE':
+      return monaco.languages.CompletionItemKind.Value;
+    case 'KEY':
+      return monaco.languages.CompletionItemKind.Property;
+    case 'BOOLEAN':
+      return monaco.languages.CompletionItemKind.Constant;
+    case 'NUMBER':
+      return monaco.languages.CompletionItemKind.Value;
+    case 'STRING':
+      return monaco.languages.CompletionItemKind.Text;
+    default:
+      return monaco.languages.CompletionItemKind.Text;
+  }
+}
+function getYamlCompletionProvider(monaco, schemas) {
+  if (schemas === void 0) {
+    schemas = [];
+  }
+  // 更准确的位置分析
+  var analyzePosition = function analyzePosition(model, position) {
+    var line = model.getLineContent(position.lineNumber);
+    var column = position.column;
+    var beforeCursor = line.substring(0, column - 1);
+    var trimmedLine = line.trim();
+    // 检查是否在值位置
+    var colonIndex = beforeCursor.indexOf(':');
+    var isAfterColon = colonIndex !== -1;
+    // 如果在冒号后面，检查是否是值位置
+    var isInValuePosition = false;
+    var currentKey = null;
+    if (isAfterColon) {
+      var keyPart = beforeCursor.substring(0, colonIndex).trim();
+      // 如果键名以 - 开头（数组项），去掉 - 和后面的空格
+      if (keyPart.startsWith('- ')) {
+        keyPart = keyPart.substring(2).trim();
+      } else if (keyPart === '-') {
+        // 如果只有一个 -，说明键名在下一个词
+        keyPart = '';
+      }
+      currentKey = keyPart;
+      // 检查冒号后面是否有空格或者光标紧跟在冒号后面
+      var afterColon = beforeCursor.substring(colonIndex + 1);
+      isInValuePosition = afterColon.length === 0 || /^\s+$/.test(afterColon);
+    }
+    // 检查是否已经有完整的值
+    var hasCompleteValue = trimmedLine.includes(':') && !trimmedLine.endsWith(':') && trimmedLine.split(':')[1].trim().length > 0;
+    return {
+      isInKeyPosition: !isAfterColon || trimmedLine.endsWith(':'),
+      isInValuePosition: isInValuePosition && !hasCompleteValue,
+      isAtEndOfCompletedValue: hasCompleteValue,
+      currentKey: currentKey,
+      line: trimmedLine,
+      beforeCursor: beforeCursor,
+      afterCursor: line.substring(column - 1)
+    };
+  }; // 从 schemas 中提取某个键的枚举值
+  var getEnumValuesFromSchemas = function getEnumValuesFromSchemas(keyName, path) {
+    if (path === void 0) {
+      path = [];
+    }
+    var completions = [];
+    for (var _iterator = _createForOfIteratorHelperLoose(schemas), _step; !(_step = _iterator()).done;) {
+      var schemaItem = _step.value;
+      var enumValues = extractEnumValues(schemaItem.schema, keyName, path);
+      completions.push.apply(completions, enumValues);
+    }
+    return completions;
+  };
+  // 递归提取 schema 中的枚举值
+  var extractEnumValues = function extractEnumValues(schema, targetKey, currentPath) {
+    if (currentPath === void 0) {
+      currentPath = [];
+    }
+    var completions = [];
+    if (!schema || !schema.properties) {
+      return completions;
+    }
+    // 如果路径为空，直接在当前层级查找
+    if (currentPath.length === 0) {
+      var prop = schema.properties[targetKey];
+      if (prop && prop["enum"]) {
+        return createEnumCompletions(prop);
+      }
+      return completions;
+    }
+    // 按路径导航到目标位置
+    var currentSchema = schema;
+    for (var _iterator2 = _createForOfIteratorHelperLoose(currentPath), _step2; !(_step2 = _iterator2()).done;) {
+      var pathSegment = _step2.value;
+      if (currentSchema.properties && currentSchema.properties[pathSegment]) {
+        currentSchema = currentSchema.properties[pathSegment];
+        // 如果是数组类型，使用 items 的 schema
+        if (currentSchema.type === 'array' && currentSchema.items) {
+          currentSchema = currentSchema.items;
+        }
+      } else {
+        // 路径不存在，返回空
+        return completions;
+      }
+    }
+    // 在目标位置查找枚举值
+    if (currentSchema.properties && currentSchema.properties[targetKey]) {
+      var _prop = currentSchema.properties[targetKey];
+      if (_prop["enum"]) {
+        return createEnumCompletions(_prop);
+      }
+    }
+    return completions;
+  };
+  // 创建枚举值补全项，支持 enumDescriptions 描述
+  var createEnumCompletions = function createEnumCompletions(prop) {
+    var completions = [];
+    if (!prop["enum"]) {
+      return completions;
+    }
+    prop["enum"].forEach(function (enumValue, index) {
+      var description = prop.description || "Enum value: " + enumValue;
+      // 如果有 enumDescriptions 数组，使用对应索引的描述
+      if (prop.enumDescriptions && prop.enumDescriptions[index]) {
+        description = prop.enumDescriptions[index];
+      }
+      completions.push({
+        label: enumValue,
+        insertText: enumValue,
+        detail: description,
+        documentation: description,
+        type: 'VALUE'
+      });
+    });
+    return completions;
+  };
+  // 从 schemas 中提取可用的键名
+  var getKeyCompletionsFromSchemas = function getKeyCompletionsFromSchemas(path) {
+    if (path === void 0) {
+      path = [];
+    }
+    var completions = [];
+    var addedKeys = new Set(); // 避免重复
+    for (var _iterator3 = _createForOfIteratorHelperLoose(schemas), _step3; !(_step3 = _iterator3()).done;) {
+      var schemaItem = _step3.value;
+      var keyCompletions = extractKeyCompletions(schemaItem.schema, path);
+      for (var _iterator4 = _createForOfIteratorHelperLoose(keyCompletions), _step4; !(_step4 = _iterator4()).done;) {
+        var completion = _step4.value;
+        if (!addedKeys.has(completion.label)) {
+          addedKeys.add(completion.label);
+          completions.push(completion);
+        }
+      }
+    }
+    return completions;
+  };
+  // 递归提取 schema 中的键名
+  var extractKeyCompletions = function extractKeyCompletions(schema, targetPath) {
+    if (targetPath === void 0) {
+      targetPath = [];
+    }
+    var completions = [];
+    var currentSchema = schema;
+    // 导航到目标路径
+    for (var _iterator5 = _createForOfIteratorHelperLoose(targetPath), _step5; !(_step5 = _iterator5()).done;) {
+      var pathSegment = _step5.value;
+      if (currentSchema.properties && currentSchema.properties[pathSegment]) {
+        currentSchema = currentSchema.properties[pathSegment];
+        if (currentSchema.type === 'array' && currentSchema.items) {
+          currentSchema = currentSchema.items;
+        }
+      } else {
+        return completions; // 路径不存在
+      }
+    }
+    // 获取当前层级的属性
+    if (currentSchema.properties) {
+      for (var _i = 0, _Object$entries = Object.entries(currentSchema.properties); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _Object$entries[_i],
+          key = _Object$entries$_i[0],
+          property = _Object$entries$_i[1];
+        var prop = property;
+        var insertText = key + ": ";
+        var shouldTriggerOnInsert = false;
+        // 根据属性类型调整插入文本和是否触发补全
+        if (prop.type === 'object') {
+          insertText = key + ":\n  ";
+          shouldTriggerOnInsert = true; // 对象类型需要触发键补全
+        } else if (prop.type === 'array') {
+          insertText = key + ":\n  - ";
+          shouldTriggerOnInsert = true; // 数组类型需要触发补全
+        } else if (prop["enum"] && prop["enum"].length > 0) {
+          // 有枚举值的字段需要触发值补全
+          shouldTriggerOnInsert = true;
+        } else if (prop.type === 'boolean') {
+          // 布尔类型需要触发 true/false 补全
+          shouldTriggerOnInsert = true;
+        } else if (prop.type === 'number') {
+          // 数字类型需要触发数字补全
+          shouldTriggerOnInsert = true;
+        }
+        // 对于普通字符串字段，不触发补全
+        completions.push({
+          label: key,
+          insertText: insertText,
+          detail: prop.description || "Property: " + key,
+          documentation: prop.description,
+          type: 'KEY',
+          triggerOnInsert: shouldTriggerOnInsert
+        });
+      }
+    }
+    return completions;
+  };
+  var getFieldType = function getFieldType(keyName, path) {
+    if (path === void 0) {
+      path = [];
+    }
+    for (var _iterator6 = _createForOfIteratorHelperLoose(schemas), _step6; !(_step6 = _iterator6()).done;) {
+      var schemaItem = _step6.value;
+      var fieldType = extractFieldType(schemaItem.schema, keyName, path);
+      if (fieldType) {
+        return fieldType;
+      }
+    }
+    return null;
+  };
+  var extractFieldType = function extractFieldType(schema, targetKey, currentPath) {
+    if (currentPath === void 0) {
+      currentPath = [];
+    }
+    if (!schema || !schema.properties) {
+      return null;
+    }
+    // 如果路径为空，直接在当前层级查找
+    if (currentPath.length === 0) {
+      var prop = schema.properties[targetKey];
+      return prop ? prop.type : null;
+    }
+    // 按路径导航到目标位置
+    var currentSchema = schema;
+    for (var _iterator7 = _createForOfIteratorHelperLoose(currentPath), _step7; !(_step7 = _iterator7()).done;) {
+      var pathSegment = _step7.value;
+      if (currentSchema.properties && currentSchema.properties[pathSegment]) {
+        currentSchema = currentSchema.properties[pathSegment];
+        // 如果是数组类型，使用 items 的 schema
+        if (currentSchema.type === 'array' && currentSchema.items) {
+          currentSchema = currentSchema.items;
+        }
+      } else {
+        // 路径不存在，返回空
+        return null;
+      }
+    }
+    // 在目标位置查找字段类型
+    if (currentSchema.properties && currentSchema.properties[targetKey]) {
+      var _prop2 = currentSchema.properties[targetKey];
+      return _prop2.type;
+    }
+    return null;
+  };
+  var getCompletions = function getCompletions(model, position) {
+    var wordInfo = model.getWordAtPosition(position);
+    var word = wordInfo ? wordInfo.word : '';
+    // 使用新的位置分析
+    var positionInfo = analyzePosition(model, position);
+    var currentPath = getCurrentPath(model, position);
+    var completions = [];
+    // 如果已经有完整的值，不提供任何补全
+    if (positionInfo.isAtEndOfCompletedValue) {
+      return [];
+    }
+    // 如果在值位置，提供值的补全
+    if (positionInfo.isInValuePosition && positionInfo.currentKey) {
+      // 查找枚举值补全
+      var enumCompletions = getEnumValuesFromSchemas(positionInfo.currentKey, currentPath);
+      if (enumCompletions.length > 0) {
+        // 如果有枚举值，只返回枚举值
+        completions.push.apply(completions, enumCompletions);
+      } else {
+        // 如果没有枚举值，检查字段类型
+        var fieldType = getFieldType(positionInfo.currentKey, currentPath);
+        if (fieldType === 'boolean') {
+          // 只为布尔类型提供 true/false
+          completions.push({
+            label: 'true',
+            insertText: 'true',
+            detail: 'Boolean true value',
+            type: 'BOOLEAN'
+          }, {
+            label: 'false',
+            insertText: 'false',
+            detail: 'Boolean false value',
+            type: 'BOOLEAN'
+          });
+        } else if (fieldType === 'number') {
+          // 为数字类型提供基本示例
+          completions.push({
+            label: '0',
+            insertText: '0',
+            detail: 'Number value',
+            type: 'NUMBER'
+          });
+        }
+        // 对于 string 类型或其他类型，不提供任何补全
+      }
+    }
+    // 如果在键位置且不在值位置，提供键的补全
+    else if (positionInfo.isInKeyPosition && !positionInfo.isInValuePosition) {
+      // 从 schemas 中获取键补全
+      var schemaKeyCompletions = getKeyCompletionsFromSchemas(currentPath);
+      completions.push.apply(completions, schemaKeyCompletions);
+    }
+    // 过滤匹配的项目
+    var filtered = completions.filter(function (item) {
+      return !word || item.label.toLowerCase().includes(word.toLowerCase());
+    });
+    return filtered;
+  };
+  var getCurrentPath = function getCurrentPath(model, position) {
+    var path = [];
+    var lines = model.getLinesContent();
+    var currentLineNumber = position.lineNumber - 1; // Monaco uses 1-based line numbers
+    if (currentLineNumber >= lines.length) {
+      return path;
+    }
+    var currentLine = lines[currentLineNumber];
+    var currentIndent = getIndentLevel(currentLine);
+    // 从当前行开始向上查找父级键
+    var targetIndent = currentIndent;
+    for (var i = currentLineNumber; i >= 0; i--) {
+      var line = lines[i];
+      var lineIndent = getIndentLevel(line);
+      var trimmed = line.trim();
+      // 跳过空行和注释
+      if (!trimmed || trimmed.startsWith('#')) {
+        continue;
+      }
+      // 如果缩进小于目标缩进
+      if (lineIndent < targetIndent) {
+        // 检查是否是数组项（以 - 开头）
+        if (trimmed.startsWith('-')) {
+          // 数组项不添加到路径中，只更新缩进继续查找
+          targetIndent = lineIndent;
+          continue;
+        }
+        // 如果包含冒号，这是一个父级键
+        if (trimmed.includes(':')) {
+          var key = trimmed.split(':')[0].trim();
+          if (key) {
+            path.unshift(key);
+            targetIndent = lineIndent; // 更新目标缩进，继续向上查找
+          }
+        }
+      }
+    }
+    return path;
+  };
+  var getIndentLevel = function getIndentLevel(line) {
+    return line.length - line.trimLeft().length;
+  };
+  var provideCompletionItems = function provideCompletionItems(model, position) {
+    var word = model.getWordAtPosition(position);
+    var range = word != null ? monaco.Range.lift({
+      startLineNumber: position.lineNumber,
+      endLineNumber: position.lineNumber,
+      startColumn: word.startColumn,
+      endColumn: word.endColumn
+    }) : monaco.Range.fromPositions(position);
+    var items = getCompletions(model, position);
+    var suggestions = items.map(function (item, index) {
+      return {
+        kind: getMonacoCompletionItemKind$1(item.type, monaco),
+        label: item.label,
+        insertText: item.insertText,
+        detail: item.detail,
+        documentation: item.documentation,
+        sortText: index.toString().padStart(3, '0'),
+        range: range,
+        command: item.triggerOnInsert ? {
+          id: 'editor.action.triggerSuggest',
+          title: ''
+        } : undefined
+      };
+    });
+    return {
+      suggestions: suggestions
+    };
+  };
+  return {
+    triggerCharacters: [':', ' ', '-', '\n', '\t'],
+    provideCompletionItems: provideCompletionItems
+  };
+}
+
+function validateYaml(content, schemas) {
+  if (schemas === void 0) {
+    schemas = [];
+  }
+  var errors = [];
+  if (!content.trim()) {
+    return errors;
+  }
+  try {
+    // 基础 YAML 语法验证
+    var lines = content.split('\n');
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i];
+      var lineNumber = i + 1;
+      // 检查缩进一致性
+      if (line.trim() && !isValidIndentation(line)) {
+        errors.push({
+          message: 'Invalid indentation. YAML requires consistent indentation.',
+          startLineNumber: lineNumber,
+          endLineNumber: lineNumber,
+          startColumn: 1,
+          endColumn: line.length + 1,
+          severity: 'error'
+        });
+      }
+      // 检查冒号后是否有空格
+      var colonMatch = line.match(/^(\s*)([^:\s]+)(:)(\S)/);
+      if (colonMatch) {
+        var startColumn = colonMatch[1].length + colonMatch[2].length + 2;
+        errors.push({
+          message: 'Missing space after colon. Use ": " instead of ":"',
+          startLineNumber: lineNumber,
+          endLineNumber: lineNumber,
+          startColumn: startColumn,
+          endColumn: startColumn + 1,
+          severity: 'error'
+        });
+      }
+      // 检查列表项格式
+      var listMatch = line.match(/^(\s*)-(\S)/);
+      if (listMatch) {
+        var _startColumn = listMatch[1].length + 2;
+        errors.push({
+          message: 'Missing space after dash. Use "- " instead of "-"',
+          startLineNumber: lineNumber,
+          endLineNumber: lineNumber,
+          startColumn: _startColumn,
+          endColumn: _startColumn + 1,
+          severity: 'error'
+        });
+      }
+    }
+    // Schema 验证
+    if (schemas.length > 0) {
+      var schemaErrors = validateAgainstSchemas(content, schemas);
+      errors.push.apply(errors, schemaErrors);
+    }
+  } catch (error) {
+    errors.push({
+      message: "YAML parsing error: " + error,
+      startLineNumber: 1,
+      endLineNumber: 1,
+      startColumn: 1,
+      endColumn: 1,
+      severity: 'error'
+    });
+  }
+  return errors;
+}
+function isValidIndentation(line) {
+  var trimmed = line.trim();
+  if (!trimmed) return true;
+  var leadingSpaces = line.length - line.trimLeft().length;
+  // YAML 通常使用 2 或 4 个空格缩进
+  return leadingSpaces % 2 === 0;
+}
+function validateAgainstSchemas(_content, _schemas) {
+  var errors = [];
+  // TODO: 实现更复杂的 schema 验证逻辑
+  // 目前提供基础的结构验证
+  // 可以在这里添加对 content 和 schemas 的具体验证
+  return errors;
+}
+
+var _templateObject$1, _templateObject2$1;
+var YAML_LANG_ID = 'yaml';
+var SIZE_MAP$1 = {
+  small: {
+    className: 'ant-input-sm',
+    top: 1,
+    bottom: 1
+  },
+  middle: {
+    className: 'ant-input-md',
+    top: 1,
+    bottom: 1
+  },
+  large: {
+    className: 'ant-input-lg',
+    top: 3,
+    bottom: 2
+  }
+};
+var themeMap$1 = {
+  light: 'yaml-light',
+  dark: 'yaml-dark'
+};
+var containerDisabledClassName$1 = /*#__PURE__*/css(_templateObject$1 || (_templateObject$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  .monaco-editor {\n    user-select: none;\n    pointer-events: none;\n  }\n"])));
+var containerReadOnlyClassName$1 = /*#__PURE__*/css(_templateObject2$1 || (_templateObject2$1 = /*#__PURE__*/_taggedTemplateLiteralLoose(["\n  .monaco-editor .cursors-layer > .cursor {\n    opacity: 0 !important;\n  }\n"])));
+var getStyles$1 = function getStyles(placeholder) {
+  return {
+    placeholder: css({
+      '::after': {
+        content: "'" + placeholder + "'",
+        opacity: 0.6
+      }
+    })
+  };
+};
+function YamlEditor(props) {
+  var id = v4();
+  var _props$size = props.size,
+    size = _props$size === void 0 ? 'middle' : _props$size,
+    _props$theme = props.theme,
+    theme = _props$theme === void 0 ? 'light' : _props$theme,
+    value = props.value,
+    placeholder = props.placeholder,
+    _props$enableAutocomp = props.enableAutocomplete,
+    enableAutocomplete = _props$enableAutocomp === void 0 ? true : _props$enableAutocomp,
+    _props$readOnly = props.readOnly,
+    readOnly = _props$readOnly === void 0 ? false : _props$readOnly,
+    _props$disabled = props.disabled,
+    disabled = _props$disabled === void 0 ? false : _props$disabled,
+    _props$schemas = props.schemas,
+    schemas = _props$schemas === void 0 ? [] : _props$schemas,
+    onChange = props.onChange,
+    onEnter = props.onEnter,
+    onBlur = props.onBlur,
+    editorDidMount = props.editorDidMount;
+  var autocompleteDisposeFun = useRef(null);
+  var containerRef = useRef(null);
+  var editorRef = useRef(null);
+  var styles = getStyles$1(placeholder);
+  var handleEditorDidMount = function handleEditorDidMount(editor$1) {
+    editorRef.current = editor$1;
+    // 定义主题
+    editor.defineTheme('yaml-light', {
+      base: 'vs',
+      inherit: true,
+      rules: [{
+        token: 'key',
+        foreground: '0000FF'
+      }, {
+        token: 'string',
+        foreground: '008000'
+      }, {
+        token: 'number',
+        foreground: '098658'
+      }, {
+        token: 'comment',
+        foreground: '008000',
+        fontStyle: 'italic'
+      }, {
+        token: 'delimiter',
+        foreground: '000000'
+      }, {
+        token: 'tag',
+        foreground: '800080'
+      }, {
+        token: 'keyword',
+        foreground: '0000FF',
+        fontStyle: 'bold'
+      }],
+      colors: {
+        'editor.background': '#00000000',
+        focusBorder: '#00000000'
+      }
+    });
+    editor.defineTheme('yaml-dark', {
+      base: 'vs-dark',
+      inherit: true,
+      rules: [{
+        token: 'key',
+        foreground: '9CDCFE'
+      }, {
+        token: 'string',
+        foreground: 'CE9178'
+      }, {
+        token: 'number',
+        foreground: 'B5CEA8'
+      }, {
+        token: 'comment',
+        foreground: '6A9955',
+        fontStyle: 'italic'
+      }, {
+        token: 'delimiter',
+        foreground: 'D4D4D4'
+      }, {
+        token: 'tag',
+        foreground: 'C586C0'
+      }, {
+        token: 'keyword',
+        foreground: '569CD6',
+        fontStyle: 'bold'
+      }],
+      colors: {
+        'editor.background': '#00000000',
+        focusBorder: '#00000000'
+      }
+    });
+    var isEditorFocused = editor$1.createContextKey('isEditorFocused' + id, false);
+    // 设置焦点状态
+    editor$1.onDidBlurEditorWidget(function () {
+      isEditorFocused.set(false);
+      onBlur == null || onBlur(editor$1.getValue());
+      var position = editor$1.getPosition();
+      if (position) {
+        var newSelection = new Selection(position.lineNumber, position.column, position.lineNumber, position.column);
+        editor$1.setSelection(newSelection);
+      }
+    });
+    editor$1.onDidFocusEditorText(function () {
+      isEditorFocused.set(true);
+    });
+    // 设置编辑器高度自适应
+    var updateElementHeight = function updateElementHeight() {
+      var containerDiv = containerRef.current;
+      if (containerDiv !== null) {
+        var pixelHeight = Math.max(editor$1.getContentHeight(), 20);
+        containerDiv.style.height = pixelHeight + "px";
+        containerDiv.style.width = '100%';
+        var pixelWidth = containerDiv.clientWidth;
+        editor$1.layout({
+          width: pixelWidth,
+          height: pixelHeight
+        });
+      }
+    };
+    editor$1.onDidContentSizeChange(updateElementHeight);
+    updateElementHeight();
+    // 禁用默认的搜索快捷键
+    editor.addKeybindingRule({
+      keybinding: KeyMod.CtrlCmd | KeyCode.KeyF,
+      command: null
+    });
+    // Shift + Enter 换行
+    editor$1.addCommand(KeyMod.Shift | KeyCode.Enter, function () {
+      var position = editor$1.getPosition();
+      if (position) {
+        editor$1.executeEdits('shift-enter', [{
+          range: new Range(position.lineNumber, position.column, position.lineNumber, position.column),
+          text: '\n'
+        }]);
+        editor$1.setPosition({
+          lineNumber: position.lineNumber + 1,
+          column: 1
+        });
+      }
+    }, 'isEditorFocused' + id);
+    // Enter 键处理 - 移除阻止默认行为的规则，允许正常换行
+    // 只有当提供了 onEnter 回调且没有建议窗口时才触发回调
+    if (onEnter) {
+      editor$1.addCommand(KeyCode.Enter, function () {
+        onEnter(editor$1.getValue());
+      }, '!suggestWidgetVisible && isEditorFocused' + id);
+    }
+    // 内容变化时进行验证
+    editor$1.onDidChangeModelContent(function () {
+      var model = editor$1.getModel();
+      if (model) {
+        var content = model.getValue();
+        var errors = validateYaml(content, schemas);
+        var markers = errors.map(function (error) {
+          return {
+            message: error.message,
+            severity: error.severity === 'error' ? MarkerSeverity.Error : error.severity === 'warning' ? MarkerSeverity.Warning : MarkerSeverity.Info,
+            startLineNumber: error.startLineNumber,
+            endLineNumber: error.endLineNumber,
+            startColumn: error.startColumn,
+            endColumn: error.endColumn
+          };
+        });
+        editor.setModelMarkers(model, 'yaml', markers);
+      }
+    });
+    editorDidMount == null || editorDidMount(editor$1);
+  };
+  useEffect(function () {
+    // 注册 YAML 语言
+    languages.register({
+      id: YAML_LANG_ID,
+      aliases: ['YAML', 'yaml'],
+      extensions: ['.yaml', '.yml'],
+      mimetypes: ['application/x-yaml', 'text/x-yaml']
+    });
+    // 设置语法高亮
+    languages.setMonarchTokensProvider(YAML_LANG_ID, language$1);
+    // 设置语言配置
+    languages.setLanguageConfiguration(YAML_LANG_ID, languageConfiguration$1);
+    return function () {
+      autocompleteDisposeFun.current == null || autocompleteDisposeFun.current();
+    };
+  }, []);
+  useEffect(function () {
+    var editor = editorRef.current;
+    if (!editor) return;
+    // 清理之前的自动补全提供器
+    if (autocompleteDisposeFun.current) {
+      autocompleteDisposeFun.current();
+      autocompleteDisposeFun.current = null;
+    }
+    // 如果启用自动补全，设置新的补全提供器
+    if (enableAutocomplete) {
+      var completionProvider = getYamlCompletionProvider(monaco, schemas);
+      var filteringCompletionProvider = _extends({}, completionProvider, {
+        provideCompletionItems: function provideCompletionItems(model, position, context, token) {
+          var _editor$getModel;
+          if (((_editor$getModel = editor.getModel()) == null ? void 0 : _editor$getModel.id) !== model.id) {
+            return {
+              suggestions: []
+            };
+          }
+          return completionProvider.provideCompletionItems(model, position, context, token);
+        }
+      });
+      var _monaco$languages$reg = languages.registerCompletionItemProvider(YAML_LANG_ID, filteringCompletionProvider),
+        dispose = _monaco$languages$reg.dispose;
+      autocompleteDisposeFun.current = dispose;
+    }
+    // 处理占位符
+    var model = editor.getModel();
+    if (model) {
+      model.deltaDecorations(model.getAllDecorations().map(function (d) {
+        return d.id;
+      }), []);
+    }
+    if (placeholder) {
+      var placeholderDecorators = [{
+        range: new Range(1, 1, 1, 1),
+        options: {
+          className: styles.placeholder,
+          isWholeLine: true
+        }
+      }];
+      var decorators = [];
+      var checkDecorators = function checkDecorators() {
+        var model = editor.getModel();
+        if (!model) return;
+        var newDecorators = model.getValueLength() === 0 ? placeholderDecorators : [];
+        decorators = model.deltaDecorations(decorators, newDecorators);
+      };
+      checkDecorators();
+      editor.onDidChangeModelContent(checkDecorators);
+    }
+  }, [enableAutocomplete, JSON.stringify(schemas), placeholder]);
+  return React.createElement("div", {
+    className: 'ant-input' + (size ? " " + SIZE_MAP$1[size].className : '') + (disabled ? " ant-input-disabled " + containerDisabledClassName$1 : '') + (readOnly ? " " + containerReadOnlyClassName$1 : '')
+  }, React.createElement("div", {
+    ref: containerRef
+  }, React.createElement(MonacoEditor, {
+    width: '100%',
+    height: '100%',
+    language: YAML_LANG_ID,
+    theme: themeMap$1[theme],
+    value: value,
+    onChange: onChange,
+    editorDidMount: handleEditorDidMount,
+    options: {
+      readOnly: readOnly,
+      codeLens: false,
+      contextmenu: false,
+      fixedOverflowWidgets: true,
+      folding: true,
+      fontSize: 12,
+      lineDecorationsWidth: 0,
+      lineNumbers: 'on',
+      minimap: {
+        enabled: false
+      },
+      overviewRulerBorder: false,
+      overviewRulerLanes: 0,
+      padding: {
+        top: SIZE_MAP$1[size].top,
+        bottom: SIZE_MAP$1[size].bottom
+      },
+      renderLineHighlight: 'line',
+      scrollbar: {
+        vertical: 'auto',
+        verticalScrollbarSize: 8,
+        horizontal: 'auto',
+        horizontalScrollbarSize: 8,
+        alwaysConsumeMouseWheel: false
+      },
+      scrollBeyondLastLine: false,
+      suggest: {
+        showWords: true,
+        filterGraceful: true,
+        snippetsPreventQuickSuggestions: false,
+        shareSuggestSelections: false
+      },
+      quickSuggestions: {
+        other: true,
+        comments: false,
+        strings: true
+      },
+      quickSuggestionsDelay: 0,
+      suggestFontSize: 12,
+      wordWrap: 'on',
+      automaticLayout: true,
+      occurrencesHighlight: 'off'
+    }
+  })));
+}
+
+export { PromQLEditor as PromQLMonacoEditor, YamlEditor as YamlMonacoEditor };
 //# sourceMappingURL=monaco-editor.esm.js.map