@monaco-ai-editor/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1074 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AI_INLINE_LANGUAGES: () => AI_INLINE_LANGUAGES,
+  AiChatController: () => AiChatController,
+  EditorBus: () => EditorBus,
+  EditorController: () => EditorController,
+  EventEmitter: () => EventEmitter,
+  LANGUAGES: () => LANGUAGES,
+  LOCALES: () => LOCALES,
+  SQL_DATA_TYPES: () => SQL_DATA_TYPES,
+  SQL_FUNCTIONS: () => SQL_FUNCTIONS,
+  SQL_KEYWORDS: () => SQL_KEYWORDS,
+  THEMES: () => THEMES,
+  fetchAiCompletionNonStream: () => fetchAiCompletionNonStream,
+  fetchAiCompletionStream: () => fetchAiCompletionStream,
+  registerAiCompletionCommand: () => registerAiCompletionCommand,
+  registerAiInlineCompletion: () => registerAiInlineCompletion,
+  registerSqlCompletion: () => registerSqlCompletion
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var SQL_KEYWORDS = [
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "CREATE",
+  "TABLE",
+  "DROP",
+  "ALTER",
+  "ADD",
+  "COLUMN",
+  "INDEX",
+  "VIEW",
+  "DATABASE",
+  "SCHEMA",
+  "TRUNCATE",
+  "RENAME",
+  "AS",
+  "ON",
+  "JOIN",
+  "INNER",
+  "LEFT",
+  "RIGHT",
+  "FULL",
+  "OUTER",
+  "CROSS",
+  "NATURAL",
+  "USING",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "EXISTS",
+  "BETWEEN",
+  "LIKE",
+  "IS",
+  "NULL",
+  "TRUE",
+  "FALSE",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "IF",
+  "UNION",
+  "ALL",
+  "DISTINCT",
+  "ORDER",
+  "BY",
+  "ASC",
+  "DESC",
+  "GROUP",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "FETCH",
+  "NEXT",
+  "ROWS",
+  "ONLY",
+  "WITH",
+  "RECURSIVE",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "UNIQUE",
+  "NOT NULL",
+  "DEFAULT",
+  "CHECK",
+  "CONSTRAINT",
+  "AUTO_INCREMENT",
+  "IDENTITY",
+  "SEQUENCE",
+  "GRANT",
+  "REVOKE",
+  "COMMIT",
+  "ROLLBACK",
+  "TRANSACTION",
+  "BEGIN",
+  "SAVEPOINT",
+  "EXPLAIN"
+];
+var SQL_FUNCTIONS = [
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MIN",
+  "MAX",
+  "COALESCE",
+  "NULLIF",
+  "IFNULL",
+  "NVL",
+  "CONCAT",
+  "LENGTH",
+  "SUBSTR",
+  "SUBSTRING",
+  "TRIM",
+  "LTRIM",
+  "RTRIM",
+  "UPPER",
+  "LOWER",
+  "REPLACE",
+  "INSTR",
+  "LPAD",
+  "RPAD",
+  "CHAR_LENGTH",
+  "POSITION",
+  "NOW",
+  "CURDATE",
+  "CURTIME",
+  "DATE",
+  "TIME",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "HOUR",
+  "MINUTE",
+  "SECOND",
+  "DATEDIFF",
+  "DATE_ADD",
+  "DATE_SUB",
+  "DATEADD",
+  "DATESUB",
+  "EXTRACT",
+  "TO_DATE",
+  "TO_CHAR",
+  "DATE_FORMAT",
+  "TIMESTAMPDIFF",
+  "ROUND",
+  "CEIL",
+  "FLOOR",
+  "ABS",
+  "MOD",
+  "POWER",
+  "SQRT",
+  "SIGN",
+  "RAND",
+  "CAST",
+  "CONVERT",
+  "ROW_NUMBER",
+  "RANK",
+  "DENSE_RANK",
+  "NTILE",
+  "LAG",
+  "LEAD",
+  "FIRST_VALUE",
+  "LAST_VALUE",
+  "OVER",
+  "PARTITION",
+  "LISTAGG",
+  "GROUP_CONCAT",
+  "STRING_AGG",
+  "JSON_OBJECT",
+  "JSON_ARRAY",
+  "JSON_EXTRACT",
+  "ISNULL"
+];
+var SQL_DATA_TYPES = [
+  "INT",
+  "INTEGER",
+  "BIGINT",
+  "SMALLINT",
+  "TINYINT",
+  "DECIMAL",
+  "NUMERIC",
+  "FLOAT",
+  "DOUBLE",
+  "REAL",
+  "CHAR",
+  "VARCHAR",
+  "TEXT",
+  "NCHAR",
+  "NVARCHAR",
+  "NTEXT",
+  "DATE",
+  "TIME",
+  "DATETIME",
+  "TIMESTAMP",
+  "BOOLEAN",
+  "BOOL",
+  "BLOB",
+  "CLOB",
+  "BINARY",
+  "VARBINARY",
+  "JSON",
+  "UUID",
+  "SERIAL"
+];
+var LANGUAGES = [
+  "javascript",
+  "typescript",
+  "python",
+  "json",
+  "css",
+  "html",
+  "markdown",
+  "rust",
+  "go",
+  "sql"
+];
+var LOCALES = {
+  ZH_CN: "zh-cn",
+  EN: "en",
+  DE: "de",
+  ES: "es",
+  FR: "fr",
+  IT: "it",
+  JA: "ja",
+  KO: "ko",
+  RU: "ru"
+};
+var THEMES = [
+  { value: "vs-dark", label: "Dark" },
+  { value: "light", label: "Light" },
+  { value: "hc-black", label: "High Contrast" }
+];
+var AI_INLINE_LANGUAGES = [
+  "typescript",
+  "javascript",
+  "python",
+  "sql",
+  "java",
+  "cpp",
+  "csharp",
+  "go",
+  "rust"
+];
+
+// src/bus/EventEmitter.ts
+var EventEmitter = class {
+  constructor() {
+    this.listeners = {};
+  }
+  on(event, listener) {
+    if (!this.listeners[event]) this.listeners[event] = /* @__PURE__ */ new Set();
+    this.listeners[event].add(listener);
+    return () => this.off(event, listener);
+  }
+  off(event, listener) {
+    this.listeners[event]?.delete(listener);
+  }
+  emit(event, payload) {
+    this.listeners[event]?.forEach((listener) => {
+      try {
+        listener(payload);
+      } catch (err) {
+        console.error(`[EventEmitter] listener for "${String(event)}" threw:`, err);
+      }
+    });
+  }
+  removeAllListeners() {
+    this.listeners = {};
+  }
+};
+
+// src/completion/sqlCompletion.ts
+function parseDynamicItems(sql) {
+  const tables = [];
+  const variables = [];
+  let m;
+  const tableRe = /\b(?:FROM|JOIN|UPDATE|INTO|TABLE)\s+([`"']?\w+[`"']?)/gi;
+  while ((m = tableRe.exec(sql)) !== null) {
+    const name = m[1].replace(/[`"']/g, "");
+    if (!tables.includes(name)) tables.push(name);
+  }
+  const cteRe = /\bWITH\s+(\w+)\s+AS\s*\(/gi;
+  while ((m = cteRe.exec(sql)) !== null) {
+    if (!tables.includes(m[1])) tables.push(m[1]);
+  }
+  const declareRe = /\bDECLARE\s+(@?\w+)/gi;
+  while ((m = declareRe.exec(sql)) !== null) {
+    if (!variables.includes(m[1])) variables.push(m[1]);
+  }
+  const setVarRe = /\bSET\s+(@\w+)\s*=/gi;
+  while ((m = setVarRe.exec(sql)) !== null) {
+    if (!variables.includes(m[1])) variables.push(m[1]);
+  }
+  const atVarRe = /@(\w+)/g;
+  while ((m = atVarRe.exec(sql)) !== null) {
+    const v = `@${m[1]}`;
+    if (!variables.includes(v)) variables.push(v);
+  }
+  return { tables, variables };
+}
+function registerSqlCompletion(monaco, schemaRef, excludeLabelsRef) {
+  return monaco.languages.registerCompletionItemProvider("sql", {
+    triggerCharacters: ["."],
+    provideCompletionItems(model, position, context) {
+      const word = model.getWordUntilPosition(position);
+      const range = {
+        startLineNumber: position.lineNumber,
+        endLineNumber: position.lineNumber,
+        startColumn: word.startColumn,
+        endColumn: word.endColumn
+      };
+      if (context.triggerCharacter === ".") {
+        const lineText = model.getLineContent(position.lineNumber);
+        const textBeforeDot = lineText.substring(0, position.column - 2);
+        const tableMatch = textBeforeDot.match(/(\w+)$/);
+        if (tableMatch) {
+          const typed = tableMatch[1].toUpperCase();
+          const schema2 = schemaRef.current;
+          const tableKey = Object.keys(schema2).find((k) => k.toUpperCase() === typed);
+          if (tableKey) {
+            const colRange = {
+              startLineNumber: position.lineNumber,
+              endLineNumber: position.lineNumber,
+              startColumn: position.column,
+              endColumn: position.column
+            };
+            return {
+              suggestions: schema2[tableKey].map((col) => ({
+                label: col,
+                kind: monaco.languages.CompletionItemKind.Field,
+                insertText: col,
+                range: colRange,
+                detail: `${tableKey} \xB7 \u5217`,
+                documentation: `\u8868 ${tableKey} \u7684\u5B57\u6BB5`
+              }))
+            };
+          }
+        }
+        return { suggestions: [] };
+      }
+      const fullText = model.getValue();
+      const { tables: dynamicTables, variables } = parseDynamicItems(fullText);
+      const schema = schemaRef.current;
+      const schemaTables = Object.keys(schema);
+      const allTables = [.../* @__PURE__ */ new Set([...schemaTables, ...dynamicTables])];
+      const exclude = excludeLabelsRef?.current;
+      const isExcluded = (label) => exclude?.has(label.toUpperCase()) ?? false;
+      const keywords = SQL_KEYWORDS.filter((kw) => !isExcluded(kw)).map((kw) => ({
+        label: kw,
+        kind: monaco.languages.CompletionItemKind.Keyword,
+        insertText: kw,
+        range,
+        detail: "SQL \u5173\u952E\u5B57"
+      }));
+      const functions = SQL_FUNCTIONS.filter((fn) => !isExcluded(fn)).map((fn) => ({
+        label: fn,
+        kind: monaco.languages.CompletionItemKind.Function,
+        insertText: `${fn}($1)`,
+        insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+        range,
+        detail: "SQL \u51FD\u6570"
+      }));
+      const dataTypes = SQL_DATA_TYPES.map((dt) => ({
+        label: dt,
+        kind: monaco.languages.CompletionItemKind.TypeParameter,
+        insertText: dt,
+        range,
+        detail: "SQL \u6570\u636E\u7C7B\u578B"
+      }));
+      const tableItems = allTables.map((t) => ({
+        label: t,
+        kind: monaco.languages.CompletionItemKind.Class,
+        insertText: t,
+        range,
+        detail: schemaTables.includes(t) ? "\u8868\u540D (Schema)" : "\u8868\u540D (\u6587\u6863)"
+      }));
+      const variableItems = variables.map((v) => ({
+        label: v,
+        kind: monaco.languages.CompletionItemKind.Variable,
+        insertText: v,
+        range,
+        detail: "SQL \u53D8\u91CF"
+      }));
+      return {
+        suggestions: [...keywords, ...functions, ...dataTypes, ...tableItems, ...variableItems]
+      };
+    }
+  });
+}
+
+// src/ai/aiCompletion.ts
+function stripCodeFence(text) {
+  return text.replace(/^```[a-z]*\n?/, "").replace(/\n?```$/, "");
+}
+var SPINNER_FRAMES = ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"];
+function ensureSpinnerStyle() {
+  const id = "mae-ai-completion-spinner-style";
+  if (typeof document === "undefined" || document.getElementById(id)) return;
+  const style = document.createElement("style");
+  style.id = id;
+  const frameCss = SPINNER_FRAMES.map((ch, i) => `.mae-ai-spinner-f${i}::after { content: " ${ch}"; }`).join("\n");
+  style.textContent = `
+@keyframes mae-ai-completion-glow {
+  0%, 100% { text-shadow: 0 0 3px rgba(96, 165, 250, 0.35); }
+  50%       { text-shadow: 0 0 9px rgba(96, 165, 250, 0.95), 0 0 18px rgba(59, 130, 246, 0.35); }
+}
+${frameCss}
+[class^="mae-ai-spinner-f"]::after {
+  color: #60a5fa;
+  font-family: "Segoe UI Symbol", "Noto Sans Symbols", "Apple Symbols", monospace;
+  display: inline-block;
+  margin-left: 2px;
+  animation: mae-ai-completion-glow 1s ease-in-out infinite;
+}`;
+  document.head.appendChild(style);
+}
+function createCursorSpinner(editor, line, col) {
+  ensureSpinnerStyle();
+  let frameIdx = 0;
+  const makeDecor = () => [{
+    range: { startLineNumber: line, startColumn: col, endLineNumber: line, endColumn: col },
+    options: { afterContentClassName: `mae-ai-spinner-f${frameIdx}` }
+  }];
+  const collection = editor.createDecorationsCollection(makeDecor());
+  const timer = setInterval(() => {
+    frameIdx = (frameIdx + 1) % SPINNER_FRAMES.length;
+    collection.set(makeDecor());
+  }, 80);
+  return () => {
+    clearInterval(timer);
+    collection.clear();
+  };
+}
+async function fetchAiCompletionNonStream(config, context, prefix, signal) {
+  const response = await fetch(`${config.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+    body: JSON.stringify({
+      model: config.model,
+      messages: [
+        {
+          role: "system",
+          content: "\u4F60\u662F\u4E00\u4E2A\u4EE3\u7801\u8865\u5168\u52A9\u624B\u3002\u57FA\u4E8E\u7528\u6237\u63D0\u4F9B\u7684\u4EE3\u7801\u4E0A\u4E0B\u6587\u548C\u524D\u7F00\uFF0C\u751F\u6210\u77ED\u5C0F\u7CBE\u608D\u7684\u4EE3\u7801\u8865\u5168\u3002\u53EA\u8FD4\u56DE\u8865\u5168\u7684\u4EE3\u7801\u7247\u6BB5\uFF0C\u4E0D\u8981\u89E3\u91CA\u3002"
+        },
+        {
+          role: "user",
+          content: `\u4EE3\u7801\u4E0A\u4E0B\u6587\uFF1A
+${context}
+
+\u524D\u7F00\uFF1A${prefix}
+
+\u8BF7\u7EE7\u7EED\u8865\u5168\u8FD9\u6BB5\u4EE3\u7801\uFF0C\u53EA\u8FD4\u56DE\u8865\u5168\u90E8\u5206\u3002`
+        }
+      ],
+      max_tokens: 1024,
+      stream: false
+    }),
+    signal
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${await response.text().catch(() => "")}`);
+  }
+  const data = await response.json();
+  return stripCodeFence(data.choices?.[0]?.message?.content?.trim() ?? "");
+}
+async function fetchAiCompletionStream(config, context, prefix, onChunk, signal) {
+  const response = await fetch(`${config.baseUrl}/chat/completions`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+    body: JSON.stringify({
+      model: config.model,
+      messages: [
+        {
+          role: "system",
+          content: "\u4F60\u662F\u4E00\u4E2A\u4EE3\u7801\u8865\u5168\u52A9\u624B\u3002\u57FA\u4E8E\u7528\u6237\u63D0\u4F9B\u7684\u4EE3\u7801\u4E0A\u4E0B\u6587\u548C\u524D\u7F00\uFF0C\u751F\u6210\u77ED\u5C0F\u7CBE\u608D\u7684\u4EE3\u7801\u8865\u5168\u3002\u53EA\u8FD4\u56DE\u8865\u5168\u7684\u4EE3\u7801\u7247\u6BB5\uFF0C\u4E0D\u8981\u89E3\u91CA\u3002"
+        },
+        {
+          role: "user",
+          content: `\u4EE3\u7801\u4E0A\u4E0B\u6587\uFF1A
+${context}
+
+\u524D\u7F00\uFF1A${prefix}
+
+\u8BF7\u7EE7\u7EED\u8865\u5168\u8FD9\u6BB5\u4EE3\u7801\uFF0C\u53EA\u8FD4\u56DE\u8865\u5168\u90E8\u5206\u3002`
+        }
+      ],
+      max_tokens: 1024,
+      stream: true
+    }),
+    signal
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${await response.text().catch(() => "")}`);
+  }
+  if (!response.body) throw new Error("Response body is null");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let accumulated = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data:")) continue;
+      const data = trimmed.slice(5).trim();
+      if (data === "[DONE]") return;
+      try {
+        const parsed = JSON.parse(data);
+        const delta = parsed.choices?.[0]?.delta?.content ?? "";
+        if (delta) {
+          accumulated += delta;
+          onChunk(accumulated);
+        }
+      } catch {
+      }
+    }
+  }
+}
+function registerAiInlineCompletion(monaco, pendingRef) {
+  AI_INLINE_LANGUAGES.forEach((lang) => {
+    monaco.languages.registerInlineCompletionsProvider(lang, {
+      provideInlineCompletions: (_model, position) => {
+        const pending = pendingRef.current;
+        if (!pending) return { items: [] };
+        if (pending.lineNumber !== position.lineNumber || pending.column !== position.column) {
+          pendingRef.current = null;
+          return { items: [] };
+        }
+        return {
+          items: [
+            {
+              insertText: pending.insertText,
+              range: {
+                startLineNumber: position.lineNumber,
+                endLineNumber: position.lineNumber,
+                startColumn: position.column,
+                endColumn: position.column
+              }
+            }
+          ]
+        };
+      },
+      disposeInlineCompletions: () => {
+      }
+    });
+  });
+}
+function registerAiCompletionCommand(editor, getApiConfig, pendingRef, onLoadingChange, onError) {
+  let currentAbortController = null;
+  const isAbortError = (err) => err instanceof Error && (err.name === "AbortError" || err.message?.includes("aborted"));
+  const triggerAiCompletion = async () => {
+    const apiConfig = getApiConfig();
+    if (!apiConfig || !apiConfig.apiKey.trim()) {
+      onError?.("\u672A\u914D\u7F6E API Key\uFF0C\u8BF7\u5148\u914D\u7F6E AI \u670D\u52A1\u518D\u4F7F\u7528\u8865\u5168\u529F\u80FD\u3002");
+      return;
+    }
+    const position = editor.getPosition();
+    if (!position) return;
+    const model = editor.getModel();
+    if (!model) return;
+    const lineText = model.getLineContent(position.lineNumber);
+    const textBeforePosition = lineText.substring(0, position.column - 1);
+    if (!textBeforePosition.trim()) return;
+    const startLine = Math.max(0, position.lineNumber - 5);
+    const contextLines = [];
+    for (let i = startLine; i < position.lineNumber; i++) {
+      contextLines.push(model.getLineContent(i + 1));
+    }
+    const contextCode = contextLines.join("\n");
+    currentAbortController?.abort();
+    currentAbortController = new AbortController();
+    pendingRef.current = null;
+    const stopSpinner = createCursorSpinner(editor, position.lineNumber, position.column);
+    onLoadingChange?.(true);
+    const useStream = apiConfig.streamMode !== false;
+    try {
+      if (useStream) {
+        let triggerTimer = null;
+        const scheduleTrigger = () => {
+          if (triggerTimer !== null) clearTimeout(triggerTimer);
+          triggerTimer = setTimeout(() => {
+            triggerTimer = null;
+            if (pendingRef.current) {
+              editor.trigger("ai", "editor.action.inlineSuggest.trigger", {});
+            }
+          }, 80);
+        };
+        await fetchAiCompletionStream(
+          apiConfig,
+          contextCode,
+          textBeforePosition,
+          (accumulated) => {
+            let insertText = stripCodeFence(accumulated);
+            if (insertText.startsWith(textBeforePosition)) {
+              insertText = insertText.slice(textBeforePosition.length);
+            }
+            if (!insertText.trim()) return;
+            pendingRef.current = {
+              lineNumber: position.lineNumber,
+              column: position.column,
+              insertText
+            };
+            scheduleTrigger();
+          },
+          currentAbortController.signal
+        );
+        if (triggerTimer !== null) clearTimeout(triggerTimer);
+        if (pendingRef.current) {
+          editor.trigger("ai", "editor.action.inlineSuggest.trigger", {});
+        }
+      } else {
+        const completion = await fetchAiCompletionNonStream(
+          apiConfig,
+          contextCode,
+          textBeforePosition,
+          currentAbortController.signal
+        );
+        if (!completion) return;
+        let insertText = completion;
+        if (insertText.startsWith(textBeforePosition)) {
+          insertText = insertText.slice(textBeforePosition.length);
+        }
+        if (!insertText.trim()) return;
+        pendingRef.current = {
+          lineNumber: position.lineNumber,
+          column: position.column,
+          insertText
+        };
+        editor.trigger("ai", "editor.action.inlineSuggest.trigger", {});
+      }
+    } catch (err) {
+      if (isAbortError(err)) return;
+      const msg = err instanceof Error ? err.message : String(err);
+      onError?.(`AI \u8865\u5168\u5931\u8D25\uFF1A${msg}`);
+      console.error("[AI Completion] Error:", err);
+    } finally {
+      stopSpinner();
+      onLoadingChange?.(false);
+    }
+  };
+  return editor.onKeyDown((e) => {
+    if ((e.ctrlKey || e.metaKey) && e.altKey && e.code === "KeyL") {
+      e.preventDefault();
+      void triggerAiCompletion();
+    }
+  });
+}
+
+// src/controllers/EditorController.ts
+var EditorController = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.editor = null;
+    this.sqlProviderRegistered = false;
+    this.aiProviderRegistered = false;
+    this.pendingCompletionRef = { current: null };
+    this.customProviders = [];
+    this.disposables = [];
+    this.completed = false;
+    this.error = null;
+    this.monaco = options.monaco;
+    this.customProviders = options.completionProviders ?? [];
+    this.init();
+  }
+  init() {
+    const { language, theme, value, sqlSchema, apiConfig, editorOptions } = this.options;
+    if (!this.sqlProviderRegistered) {
+      const schemaRef = { current: sqlSchema ?? {} };
+      registerSqlCompletion(this.monaco, schemaRef);
+      this.sqlProviderRegistered = true;
+    }
+    if (!this.aiProviderRegistered) {
+      registerAiInlineCompletion(this.monaco, this.pendingCompletionRef);
+      this.aiProviderRegistered = true;
+    }
+    this.registerCustomCompletionProviders();
+    this.editor = this.monaco.editor.create(this.options.container, {
+      value: value ?? "",
+      language: language ?? "typescript",
+      theme: theme ?? "vs-dark",
+      fontSize: 14,
+      minimap: { enabled: true },
+      scrollBeyondLastLine: false,
+      automaticLayout: true,
+      lineNumbers: "on",
+      renderLineHighlight: "all",
+      smoothScrolling: true,
+      cursorBlinking: "smooth",
+      bracketPairColorization: { enabled: true },
+      tabSize: 2,
+      wordWrap: "on",
+      folding: true,
+      formatOnPaste: true,
+      suggestOnTriggerCharacters: true,
+      quickSuggestions: { other: true, comments: false, strings: false },
+      acceptSuggestionOnCommitCharacter: true,
+      acceptSuggestionOnEnter: "on",
+      inlineSuggest: { enabled: true },
+      tabCompletion: "on",
+      ...editorOptions
+    });
+    this.bindEditorEvents();
+    this.emit("ready", { editor: this.editor });
+  }
+  bindEditorEvents() {
+    const editor = this.editor;
+    const d1 = editor.onDidChangeModelContent(() => {
+      this.emit("change", { value: editor.getValue() });
+    });
+    const d2 = editor.onDidChangeCursorPosition((e) => {
+      this.emit("cursor", {
+        line: e.position.lineNumber,
+        column: e.position.column
+      });
+    });
+    const d3 = editor.onDidFocusEditorText(() => this.emit("focus", void 0));
+    const d4 = editor.onDidBlurEditorText(() => this.emit("blur", void 0));
+    this.disposables.push(d1, d2, d3, d4);
+  }
+  registerCustomCompletionProviders() {
+    if (this.customProviders.length === 0) return;
+    for (const provider of this.customProviders) {
+      const langs = provider.languages ?? ["*"];
+      for (const lang of langs) {
+        this.monaco.languages.registerCompletionItemProvider(lang, {
+          triggerCharacters: provider.triggerCharacters,
+          provideCompletionItems: async (model, position, context) => {
+            const ctx = {
+              monaco: this.monaco,
+              model,
+              position,
+              lineText: model.getLineContent(position.lineNumber),
+              currentWord: model.getWordUntilPosition(position).word,
+              fullText: model.getValue(),
+              triggerCharacter: context.triggerCharacter
+            };
+            if (provider.shouldTrigger && !provider.shouldTrigger(ctx)) {
+              return { suggestions: [] };
+            }
+            const suggestions = await provider.provide(ctx);
+            return { suggestions };
+          }
+        });
+      }
+    }
+  }
+  // ─── 公开 API ──────────────────────────────────────────────────────────
+  getEditor() {
+    return this.editor;
+  }
+  getValue() {
+    return this.editor?.getValue() ?? "";
+  }
+  setValue(value) {
+    this.editor?.setValue(value);
+  }
+  insertText(text, range) {
+    const editor = this.editor;
+    if (!editor) return;
+    const targetRange = range ?? editor.getSelection();
+    if (targetRange) {
+      editor.executeEdits("controller-insert", [{ range: targetRange, text }]);
+      editor.focus();
+    }
+  }
+  format() {
+    this.editor?.getAction("editor.action.formatDocument")?.run();
+  }
+  focus() {
+    this.editor?.focus();
+  }
+  setLanguage(language) {
+    const model = this.editor?.getModel();
+    if (model) {
+      this.monaco.editor.setModelLanguage(model, language);
+      this.emit("languageChange", { language });
+    }
+  }
+  setTheme(theme) {
+    this.monaco.editor.setTheme(theme);
+  }
+  getCursorPosition() {
+    const pos = this.editor?.getPosition();
+    return pos ? { line: pos.lineNumber, column: pos.column } : { line: 1, column: 1 };
+  }
+  getSelection() {
+    return this.editor?.getSelection() ?? null;
+  }
+  /**
+   * 触发 AI 行内补全（Ctrl+Alt+L 快捷键）。
+   * 需要提前设置 apiConfig（通过 setApiConfig 或构造函数传入）。
+   */
+  setApiConfig(config) {
+    this.options.apiConfig = config;
+  }
+  getPendingCompletionRef() {
+    return this.pendingCompletionRef;
+  }
+  dispose() {
+    for (const d of this.disposables) d.dispose();
+    this.disposables = [];
+    this.editor?.dispose();
+    this.editor = null;
+    this.removeAllListeners();
+  }
+};
+
+// src/controllers/AiChatController.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var AiChatController = class extends EventEmitter {
+  constructor(apiConfig) {
+    super();
+    this.messages = [];
+    this.abortController = null;
+    this.loading = false;
+    this.apiConfig = apiConfig;
+  }
+  setApiConfig(config) {
+    this.apiConfig = config;
+  }
+  getApiConfig() {
+    return this.apiConfig;
+  }
+  getMessages() {
+    return this.messages;
+  }
+  isLoading() {
+    return this.loading;
+  }
+  /** 发送消息，可选携带编辑器上下文 */
+  async send(userInput, options) {
+    const trimmed = userInput.trim();
+    if (!trimmed || this.loading) return;
+    if (!this.apiConfig.apiKey.trim()) {
+      const userMsg2 = { id: generateUUID(), role: "user", content: trimmed };
+      this.messages.push(userMsg2);
+      this.emit("messageAdded", userMsg2);
+      const assistantMsg2 = {
+        id: generateUUID(),
+        role: "assistant",
+        content: "\u26A0\uFE0F \u5C1A\u672A\u914D\u7F6E API Key\uFF0C\u8BF7\u914D\u7F6E Base URL\u3001API Key \u548C\u6A21\u578B\u540D\u79F0\u540E\u518D\u5F00\u59CB\u5BF9\u8BDD\u3002"
+      };
+      this.messages.push(assistantMsg2);
+      this.emit("messageAdded", assistantMsg2);
+      return;
+    }
+    const userMsg = { id: generateUUID(), role: "user", content: trimmed };
+    this.messages.push(userMsg);
+    this.emit("messageAdded", userMsg);
+    const assistantMsg = {
+      id: generateUUID(),
+      role: "assistant",
+      content: "",
+      isStreaming: true
+    };
+    this.messages.push(assistantMsg);
+    this.emit("messageAdded", assistantMsg);
+    this.loading = true;
+    this.emit("loadingChange", { loading: true });
+    try {
+      this.abortController = new AbortController();
+      const systemPrompt = options?.language ? `You are an expert coding assistant. The user is working with ${options.language} code. Respond concisely in the same language as the user's message, defaulting to Chinese.` : "You are an expert coding assistant. Respond concisely in the same language as the user's message, defaulting to Chinese.";
+      const historyForApi = this.messages.filter((m) => m.id !== assistantMsg.id).map((m) => ({ role: m.role, content: m.content }));
+      const response = await fetch(`${this.apiConfig.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiConfig.apiKey}`
+        },
+        body: JSON.stringify({
+          model: this.apiConfig.model,
+          messages: [{ role: "system", content: systemPrompt }, ...historyForApi],
+          stream: true
+        }),
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        let errText = "";
+        try {
+          errText = await response.text();
+        } catch {
+        }
+        let hint = "";
+        if (response.status === 401) hint = "\uFF08API Key \u65E0\u6548\u6216\u5DF2\u8FC7\u671F\uFF09";
+        else if (response.status === 403) hint = "\uFF08\u65E0\u8BBF\u95EE\u6743\u9650\uFF0C\u8BF7\u68C0\u67E5 API Key \u548C Base URL\uFF09";
+        else if (response.status === 429) hint = "\uFF08\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\uFF09";
+        else if (response.status >= 500) hint = "\uFF08\u670D\u52A1\u7AEF\u9519\u8BEF\uFF09";
+        throw new Error(`HTTP ${response.status}${hint}${errText ? `
+${errText}` : ""}`);
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      let fullContent = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (data === "[DONE]") break;
+          try {
+            const parsed = JSON.parse(data);
+            const delta = parsed.choices?.[0]?.delta?.content ?? "";
+            if (delta) {
+              fullContent += delta;
+              assistantMsg.content = fullContent;
+              this.emit("messageUpdated", { ...assistantMsg });
+            }
+          } catch {
+          }
+        }
+      }
+      assistantMsg.isStreaming = false;
+      this.emit("messageUpdated", { ...assistantMsg });
+    } catch (err) {
+      const isAbort = err instanceof Error && err.name === "AbortError";
+      const errMsg = err instanceof Error ? err.message : String(err);
+      const isNetworkErr = err instanceof TypeError && errMsg.toLowerCase().includes("fetch");
+      const errorContent = isAbort ? "\u23F9 \u8BF7\u6C42\u5DF2\u53D6\u6D88" : isNetworkErr ? `\u26A0\uFE0F \u7F51\u7EDC\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5 Base URL \u548C\u7F51\u7EDC\u3002
+
+${errMsg}` : `\u26A0\uFE0F \u8BF7\u6C42\u5931\u8D25\uFF1A${errMsg}`;
+      assistantMsg.content = errorContent;
+      assistantMsg.isStreaming = false;
+      this.emit("messageUpdated", { ...assistantMsg });
+      if (!isAbort) this.emit("error", { message: errMsg });
+    } finally {
+      this.loading = false;
+      this.emit("loadingChange", { loading: false });
+    }
+  }
+  stop() {
+    this.abortController?.abort();
+  }
+  clear() {
+    this.messages = [];
+    this.emit("cleared", void 0);
+  }
+  dispose() {
+    this.abortController?.abort();
+    this.removeAllListeners();
+  }
+};
+
+// src/bus/EditorBus.ts
+var EditorBus = class extends EventEmitter {
+  constructor() {
+    super(...arguments);
+    this.editor = null;
+    this.chat = null;
+  }
+  registerEditor(controller) {
+    this.editor = controller;
+    const offChange = controller.on("change", (data) => this.emit("editor:change", data));
+    const offCursor = controller.on("cursor", (data) => this.emit("editor:cursor", data));
+    const offLang = controller.on("languageChange", (data) => this.emit("editor:languageChange", data));
+    const offInsert = this.on("chat:insertCode", ({ code }) => controller.insertText(code));
+    const offReplace = this.on("chat:replaceCode", ({ code }) => controller.setValue(code));
+    this.emit("editor:ready", controller);
+    return () => {
+      offChange();
+      offCursor();
+      offLang();
+      offInsert();
+      offReplace();
+      if (this.editor === controller) {
+        this.editor = null;
+        this.emit("editor:dispose", void 0);
+      }
+    };
+  }
+  registerChat(controller) {
+    this.chat = controller;
+    this.emit("chat:ready", controller);
+    return () => {
+      if (this.chat === controller) {
+        this.chat = null;
+        this.emit("chat:dispose", void 0);
+      }
+    };
+  }
+  getEditor() {
+    return this.editor;
+  }
+  getChat() {
+    return this.chat;
+  }
+  /** 让聊天面板向编辑器请求当前内容 */
+  getEditorContent() {
+    return this.editor?.getValue() ?? "";
+  }
+  /** 让聊天面板向编辑器请求当前语言 */
+  getEditorLanguage() {
+    const editor = this.editor?.getEditor();
+    return editor?.getModel()?.getLanguageId();
+  }
+  /** 让聊天面板请求向编辑器插入代码 */
+  insertToEditor(code) {
+    this.emit("chat:insertCode", { code });
+  }
+  /** 让聊天面板请求替换编辑器全部内容 */
+  replaceEditor(code) {
+    this.emit("chat:replaceCode", { code });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AI_INLINE_LANGUAGES,
+  AiChatController,
+  EditorBus,
+  EditorController,
+  EventEmitter,
+  LANGUAGES,
+  LOCALES,
+  SQL_DATA_TYPES,
+  SQL_FUNCTIONS,
+  SQL_KEYWORDS,
+  THEMES,
+  fetchAiCompletionNonStream,
+  fetchAiCompletionStream,
+  registerAiCompletionCommand,
+  registerAiInlineCompletion,
+  registerSqlCompletion
+});
+//# sourceMappingURL=index.cjs.map