@coze-editor/lang-javascript 0.1.0-alpha.6b15c1

package/dist/index.d.mts

@@ -0,0 +1,29 @@
+import * as _codemirror_state from '@codemirror/state';
+import { LRLanguage, LanguageSupport } from '@codemirror/language';
+import { Completion, CompletionContext, CompletionResult, CompletionSource } from '@codemirror/autocomplete';
+import { EditorView } from '@codemirror/view';
+import { Diagnostic } from '@codemirror/lint';
+
+declare const javascriptLanguage: LRLanguage;
+declare const typescriptLanguage: LRLanguage;
+declare const jsxLanguage: LRLanguage;
+declare const tsxLanguage: LRLanguage;
+declare function javascript(config?: {
+    jsx?: boolean;
+    typescript?: boolean;
+}): LanguageSupport;
+declare const autoCloseTags: _codemirror_state.Extension;
+
+declare const snippets: readonly Completion[];
+declare const typescriptSnippets: Completion[];
+
+declare function esLint(eslint: any, config?: any): (view: EditorView) => Diagnostic[];
+
+declare function localCompletionSource(context: CompletionContext): CompletionResult | null;
+declare function completionPath(context: CompletionContext): {
+    path: readonly string[];
+    name: string;
+} | null;
+declare function scopeCompletionSource(scope: any): CompletionSource;
+
+export { autoCloseTags, completionPath, esLint, javascript, javascriptLanguage, jsxLanguage, localCompletionSource, scopeCompletionSource, snippets, tsxLanguage, typescriptLanguage, typescriptSnippets };

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+import * as _codemirror_state from '@codemirror/state';
+import { LRLanguage, LanguageSupport } from '@codemirror/language';
+import { Completion, CompletionContext, CompletionResult, CompletionSource } from '@codemirror/autocomplete';
+import { EditorView } from '@codemirror/view';
+import { Diagnostic } from '@codemirror/lint';
+
+declare const javascriptLanguage: LRLanguage;
+declare const typescriptLanguage: LRLanguage;
+declare const jsxLanguage: LRLanguage;
+declare const tsxLanguage: LRLanguage;
+declare function javascript(config?: {
+    jsx?: boolean;
+    typescript?: boolean;
+}): LanguageSupport;
+declare const autoCloseTags: _codemirror_state.Extension;
+
+declare const snippets: readonly Completion[];
+declare const typescriptSnippets: Completion[];
+
+declare function esLint(eslint: any, config?: any): (view: EditorView) => Diagnostic[];
+
+declare function localCompletionSource(context: CompletionContext): CompletionResult | null;
+declare function completionPath(context: CompletionContext): {
+    path: readonly string[];
+    name: string;
+} | null;
+declare function scopeCompletionSource(scope: any): CompletionSource;
+
+export { autoCloseTags, completionPath, esLint, javascript, javascriptLanguage, jsxLanguage, localCompletionSource, scopeCompletionSource, snippets, tsxLanguage, typescriptLanguage, typescriptSnippets };

package/dist/index.js

@@ -0,0 +1,573 @@
+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, {
+  autoCloseTags: () => autoCloseTags,
+  completionPath: () => completionPath,
+  esLint: () => esLint,
+  javascript: () => javascript,
+  javascriptLanguage: () => javascriptLanguage,
+  jsxLanguage: () => jsxLanguage,
+  localCompletionSource: () => localCompletionSource,
+  scopeCompletionSource: () => scopeCompletionSource,
+  snippets: () => snippets,
+  tsxLanguage: () => tsxLanguage,
+  typescriptLanguage: () => typescriptLanguage,
+  typescriptSnippets: () => typescriptSnippets
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/javascript.ts
+var import_javascript = require("@lezer/javascript");
+var import_view = require("@codemirror/view");
+var import_state = require("@codemirror/state");
+var import_language2 = require("@codemirror/language");
+var import_autocomplete2 = require("@codemirror/autocomplete");
+
+// src/snippets.ts
+var import_autocomplete = require("@codemirror/autocomplete");
+var snippets = [
+  (0, import_autocomplete.snippetCompletion)("function ${name}(${params}) {\n	${}\n}", {
+    label: "function",
+    detail: "definition",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("for (let ${index} = 0; ${index} < ${bound}; ${index}++) {\n	${}\n}", {
+    label: "for",
+    detail: "loop",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("for (let ${name} of ${collection}) {\n	${}\n}", {
+    label: "for",
+    detail: "of loop",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("do {\n	${}\n} while (${})", {
+    label: "do",
+    detail: "loop",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("while (${}) {\n	${}\n}", {
+    label: "while",
+    detail: "loop",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("try {\n	${}\n} catch (${error}) {\n	${}\n}", {
+    label: "try",
+    detail: "/ catch block",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("if (${}) {\n	${}\n}", {
+    label: "if",
+    detail: "block",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("if (${}) {\n	${}\n} else {\n	${}\n}", {
+    label: "if",
+    detail: "/ else block",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("class ${name} {\n	constructor(${params}) {\n		${}\n	}\n}", {
+    label: "class",
+    detail: "definition",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)('import {${names}} from "${module}"\n${}', {
+    label: "import",
+    detail: "named",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)('import ${name} from "${module}"\n${}', {
+    label: "import",
+    detail: "default",
+    type: "keyword"
+  })
+];
+var typescriptSnippets = snippets.concat([
+  (0, import_autocomplete.snippetCompletion)("interface ${name} {\n	${}\n}", {
+    label: "interface",
+    detail: "definition",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("type ${name} = ${type}", {
+    label: "type",
+    detail: "definition",
+    type: "keyword"
+  }),
+  (0, import_autocomplete.snippetCompletion)("enum ${name} {\n	${}\n}", {
+    label: "enum",
+    detail: "definition",
+    type: "keyword"
+  })
+]);
+
+// src/complete.ts
+var import_common = require("@lezer/common");
+var import_language = require("@codemirror/language");
+var cache = new import_common.NodeWeakMap();
+var ScopeNodes = /* @__PURE__ */ new Set([
+  "Script",
+  "Block",
+  "FunctionExpression",
+  "FunctionDeclaration",
+  "ArrowFunction",
+  "MethodDeclaration",
+  "ForStatement"
+]);
+function defID(type) {
+  return (node, def) => {
+    const id = node.node.getChild("VariableDefinition");
+    if (id) {
+      def(id, type);
+    }
+    return true;
+  };
+}
+var functionContext = ["FunctionDeclaration"];
+var gatherCompletions = {
+  FunctionDeclaration: defID("function"),
+  ClassDeclaration: defID("class"),
+  ClassExpression: () => true,
+  EnumDeclaration: defID("constant"),
+  TypeAliasDeclaration: defID("type"),
+  NamespaceDeclaration: defID("namespace"),
+  VariableDefinition(node, def) {
+    if (!node.matchContext(functionContext)) {
+      def(node, "variable");
+    }
+  },
+  TypeDefinition(node, def) {
+    def(node, "type");
+  },
+  __proto__: null
+};
+function getScope(doc, node) {
+  const cached = cache.get(node);
+  if (cached) {
+    return cached;
+  }
+  const completions = [];
+  let top = true;
+  function def(node2, type) {
+    const name = doc.sliceString(node2.from, node2.to);
+    completions.push({ label: name, type });
+  }
+  node.cursor(import_common.IterMode.IncludeAnonymous).iterate((node2) => {
+    if (top) {
+      top = false;
+    } else if (node2.name) {
+      const gather = gatherCompletions[node2.name];
+      if (gather && gather(node2, def) || ScopeNodes.has(node2.name)) {
+        return false;
+      }
+    } else if (node2.to - node2.from > 8192) {
+      for (const c of getScope(doc, node2.node)) {
+        completions.push(c);
+      }
+      return false;
+    }
+  });
+  cache.set(node, completions);
+  return completions;
+}
+var Identifier = /^[\w$\xa1-\uffff][\w$\d\xa1-\uffff]*$/;
+var dontComplete = [
+  "TemplateString",
+  "String",
+  "RegExp",
+  "LineComment",
+  "BlockComment",
+  "VariableDefinition",
+  "TypeDefinition",
+  "Label",
+  "PropertyDefinition",
+  "PropertyName",
+  "PrivatePropertyDefinition",
+  "PrivatePropertyName",
+  "JSXText",
+  "JSXAttributeValue",
+  "JSXOpenTag",
+  "JSXCloseTag",
+  "JSXSelfClosingTag",
+  ".",
+  "?."
+];
+function localCompletionSource(context) {
+  const inner = (0, import_language.syntaxTree)(context.state).resolveInner(context.pos, -1);
+  if (dontComplete.indexOf(inner.name) > -1) {
+    return null;
+  }
+  const isWord = inner.name == "VariableName" || inner.to - inner.from < 20 && Identifier.test(context.state.sliceDoc(inner.from, inner.to));
+  if (!isWord && !context.explicit) {
+    return null;
+  }
+  let options = [];
+  for (let pos = inner; pos; pos = pos.parent) {
+    if (ScopeNodes.has(pos.name)) {
+      options = options.concat(getScope(context.state.doc, pos));
+    }
+  }
+  return {
+    options,
+    from: isWord ? inner.from : context.pos,
+    validFor: Identifier
+  };
+}
+function pathFor(read, member, name) {
+  var _a;
+  const path = [];
+  for (; ; ) {
+    const obj = member.firstChild;
+    let prop;
+    if ((obj == null ? void 0 : obj.name) == "VariableName") {
+      path.push(read(obj));
+      return { path: path.reverse(), name };
+    } else if ((obj == null ? void 0 : obj.name) == "MemberExpression" && ((_a = prop = obj.lastChild) == null ? void 0 : _a.name) == "PropertyName") {
+      path.push(read(prop));
+      member = obj;
+    } else {
+      return null;
+    }
+  }
+}
+function completionPath(context) {
+  const read = (node) => context.state.doc.sliceString(node.from, node.to);
+  const inner = (0, import_language.syntaxTree)(context.state).resolveInner(context.pos, -1);
+  if (inner.name == "PropertyName") {
+    return pathFor(read, inner.parent, read(inner));
+  } else if ((inner.name == "." || inner.name == "?.") && inner.parent.name == "MemberExpression") {
+    return pathFor(read, inner.parent, "");
+  } else if (dontComplete.indexOf(inner.name) > -1) {
+    return null;
+  } else if (inner.name == "VariableName" || inner.to - inner.from < 20 && Identifier.test(read(inner))) {
+    return { path: [], name: read(inner) };
+  } else if (inner.name == "MemberExpression") {
+    return pathFor(read, inner, "");
+  } else {
+    return context.explicit ? { path: [], name: "" } : null;
+  }
+}
+function enumeratePropertyCompletions(obj, top) {
+  const options = [], seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; ; depth++) {
+    for (const name of (Object.getOwnPropertyNames || Object.keys)(obj)) {
+      if (!/^[a-zA-Z_$\xaa-\uffdc][\w$\xaa-\uffdc]*$/.test(name) || seen.has(name)) {
+        continue;
+      }
+      seen.add(name);
+      let value;
+      try {
+        value = obj[name];
+      } catch (_) {
+        continue;
+      }
+      options.push({
+        label: name,
+        type: typeof value === "function" ? /^[A-Z]/.test(name) ? "class" : top ? "function" : "method" : top ? "variable" : "property",
+        boost: -depth
+      });
+    }
+    const next = Object.getPrototypeOf(obj);
+    if (!next) {
+      return options;
+    }
+    obj = next;
+  }
+}
+function scopeCompletionSource(scope) {
+  const cache2 = /* @__PURE__ */ new Map();
+  return (context) => {
+    const path = completionPath(context);
+    if (!path) {
+      return null;
+    }
+    let target = scope;
+    for (const step of path.path) {
+      target = target[step];
+      if (!target) {
+        return null;
+      }
+    }
+    let options = cache2.get(target);
+    if (!options) {
+      cache2.set(
+        target,
+        options = enumeratePropertyCompletions(target, !path.path.length)
+      );
+    }
+    return {
+      from: context.pos - path.name.length,
+      options,
+      validFor: Identifier
+    };
+  };
+}
+
+// src/javascript.ts
+var javascriptLanguage = import_language2.LRLanguage.define({
+  name: "javascript",
+  parser: import_javascript.parser.configure({
+    props: [
+      import_language2.indentNodeProp.add({
+        IfStatement: (0, import_language2.continuedIndent)({ except: /^\s*({|else\b)/ }),
+        TryStatement: (0, import_language2.continuedIndent)({ except: /^\s*({|catch\b|finally\b)/ }),
+        LabeledStatement: import_language2.flatIndent,
+        SwitchBody: (context) => {
+          const after = context.textAfter, closed = /^\s*\}/.test(after), isCase = /^\s*(case|default)\b/.test(after);
+          return context.baseIndent + (closed ? 0 : isCase ? 1 : 2) * context.unit;
+        },
+        Block: (0, import_language2.delimitedIndent)({ closing: "}" }),
+        ArrowFunction: (cx) => cx.baseIndent + cx.unit,
+        "TemplateString BlockComment": () => null,
+        "Statement Property": (0, import_language2.continuedIndent)({ except: /^\s*{/ }),
+        JSXElement(context) {
+          const closed = /^\s*<\//.test(context.textAfter);
+          return context.lineIndent(context.node.from) + (closed ? 0 : context.unit);
+        },
+        JSXEscape(context) {
+          const closed = /\s*\}/.test(context.textAfter);
+          return context.lineIndent(context.node.from) + (closed ? 0 : context.unit);
+        },
+        "JSXOpenTag JSXSelfClosingTag"(context) {
+          return context.column(context.node.from) + context.unit;
+        }
+      }),
+      import_language2.foldNodeProp.add({
+        "Block ClassBody SwitchBody EnumBody ObjectExpression ArrayExpression ObjectType": import_language2.foldInside,
+        BlockComment(tree) {
+          return { from: tree.from + 2, to: tree.to - 2 };
+        },
+        JSXElement(node) {
+          var _a;
+          const first = node.firstChild;
+          const start = (first == null ? void 0 : first.firstChild) ? first.firstChild.nextSibling : null;
+          let end = null;
+          if (!first) {
+            return null;
+          }
+          if (first.name === "JSXSelfClosingTag") {
+            end = first.lastChild;
+          }
+          if (["JSXOpenTag", "JSXFragmentTag"].includes(first.name)) {
+            end = ((_a = node.lastChild) == null ? void 0 : _a.name) === "JSXCloseTag" ? node.lastChild : null;
+          }
+          if (!start || !end) {
+            return null;
+          }
+          return start && start.to < end.from ? { from: start.to, to: end.type.isError ? node.to : end.from } : null;
+        }
+      })
+    ]
+  }),
+  languageData: {
+    closeBrackets: { brackets: ["(", "[", "{", "'", '"', "`"] },
+    commentTokens: { line: "//", block: { open: "/*", close: "*/" } },
+    indentOnInput: /^\s*(?:case |default:|\{|\}|<\/)$/,
+    wordChars: "$"
+  }
+});
+var jsxSublanguage = {
+  test: (node) => /^JSX/.test(node.name),
+  facet: (0, import_language2.defineLanguageFacet)({
+    commentTokens: { block: { open: "{/*", close: "*/}" } }
+  })
+};
+var typescriptLanguage = javascriptLanguage.configure(
+  { dialect: "ts" },
+  "typescript"
+);
+var jsxLanguage = javascriptLanguage.configure({
+  dialect: "jsx",
+  props: [import_language2.sublanguageProp.add((n) => n.isTop ? [jsxSublanguage] : void 0)]
+});
+var tsxLanguage = javascriptLanguage.configure(
+  {
+    dialect: "jsx ts",
+    props: [import_language2.sublanguageProp.add((n) => n.isTop ? [jsxSublanguage] : void 0)]
+  },
+  "typescript"
+);
+var kwCompletion = (name) => ({ label: name, type: "keyword" });
+var keywords = "break case const continue default delete export extends false finally in instanceof let new return static super switch this throw true typeof var yield".split(" ").map(kwCompletion);
+var typescriptKeywords = keywords.concat(
+  ["declare", "implements", "private", "protected", "public"].map(kwCompletion)
+);
+function javascript(config = {}) {
+  const lang = config.jsx ? config.typescript ? tsxLanguage : jsxLanguage : config.typescript ? typescriptLanguage : javascriptLanguage;
+  const completions = config.typescript ? typescriptSnippets.concat(typescriptKeywords) : snippets.concat(keywords);
+  return new import_language2.LanguageSupport(lang, [
+    javascriptLanguage.data.of({
+      autocomplete: (0, import_autocomplete2.ifNotIn)(dontComplete, (0, import_autocomplete2.completeFromList)(completions))
+    }),
+    javascriptLanguage.data.of({
+      autocomplete: localCompletionSource
+    }),
+    config.jsx ? autoCloseTags : []
+  ]);
+}
+function findOpenTag(node) {
+  for (; ; ) {
+    if (node.name == "JSXOpenTag" || node.name == "JSXSelfClosingTag" || node.name == "JSXFragmentTag") {
+      return node;
+    }
+    if (node.name == "JSXEscape" || !node.parent) {
+      return null;
+    }
+    node = node.parent;
+  }
+}
+function elementName(doc, tree, max = doc.length) {
+  for (let ch = tree == null ? void 0 : tree.firstChild; ch; ch = ch.nextSibling) {
+    if (ch.name == "JSXIdentifier" || ch.name == "JSXBuiltin" || ch.name == "JSXNamespacedName" || ch.name == "JSXMemberExpression") {
+      return doc.sliceString(ch.from, Math.min(ch.to, max));
+    }
+  }
+  return "";
+}
+var android = typeof navigator === "object" && /Android\b/.test(navigator.userAgent);
+var autoCloseTags = import_view.EditorView.inputHandler.of(
+  (view, from, to, text, defaultInsert) => {
+    if ((android ? view.composing : view.compositionStarted) || view.state.readOnly || from != to || text != ">" && text != "/" || !javascriptLanguage.isActiveAt(view.state, from, -1)) {
+      return false;
+    }
+    const base = defaultInsert(), { state } = base;
+    const closeTags = state.changeByRange((range) => {
+      var _a;
+      const { head } = range;
+      let around = (0, import_language2.syntaxTree)(state).resolveInner(head - 1, -1);
+      let name;
+      if (around.name == "JSXStartTag") {
+        around = around.parent;
+      }
+      if (state.doc.sliceString(head - 1, head) != text || around.name == "JSXAttributeValue" && around.to > head) {
+      } else if (text == ">" && around.name == "JSXFragmentTag") {
+        return { range, changes: { from: head, insert: "</>" } };
+      } else if (text == "/" && around.name == "JSXStartCloseTag") {
+        const empty = around.parent, base2 = empty.parent;
+        if (base2 && empty.from == head - 2 && ((name = elementName(state.doc, base2.firstChild, head)) || ((_a = base2.firstChild) == null ? void 0 : _a.name) == "JSXFragmentTag")) {
+          const insert = `${name}>`;
+          return {
+            range: import_state.EditorSelection.cursor(head + insert.length, -1),
+            changes: { from: head, insert }
+          };
+        }
+      } else if (text == ">") {
+        const openTag = findOpenTag(around);
+        if (openTag && openTag.name == "JSXOpenTag" && !/^\/?>|^<\//.test(state.doc.sliceString(head, head + 2)) && (name = elementName(state.doc, openTag, head))) {
+          return { range, changes: { from: head, insert: `</${name}>` } };
+        }
+      }
+      return { range };
+    });
+    if (closeTags.changes.empty) {
+      return false;
+    }
+    view.dispatch([
+      base,
+      state.update(closeTags, {
+        userEvent: "input.complete",
+        scrollIntoView: true
+      })
+    ]);
+    return true;
+  }
+);
+
+// src/eslint.ts
+function esLint(eslint, config) {
+  if (!config) {
+    config = {
+      parserOptions: { ecmaVersion: 2019, sourceType: "module" },
+      env: {
+        browser: true,
+        node: true,
+        es6: true,
+        es2015: true,
+        es2017: true,
+        es2020: true
+      },
+      rules: {}
+    };
+    eslint.getRules().forEach((desc, name) => {
+      var _a;
+      if ((_a = desc.meta.docs) == null ? void 0 : _a.recommended) {
+        config.rules[name] = 2;
+      }
+    });
+  }
+  return (view) => {
+    const { state } = view, found = [];
+    for (const { from, to } of javascriptLanguage.findRegions(state)) {
+      const fromLine = state.doc.lineAt(from), offset = {
+        line: fromLine.number - 1,
+        col: from - fromLine.from,
+        pos: from
+      };
+      for (const d of eslint.verify(state.sliceDoc(from, to), config)) {
+        found.push(translateDiagnostic(d, state.doc, offset));
+      }
+    }
+    return found;
+  };
+}
+function mapPos(line, col, doc, offset) {
+  return doc.line(line + offset.line).from + col + (line == 1 ? offset.col - 1 : -1);
+}
+function translateDiagnostic(input, doc, offset) {
+  const start = mapPos(input.line, input.column, doc, offset);
+  const result = {
+    from: start,
+    to: input.endLine != null && input.endColumn != 1 ? mapPos(input.endLine, input.endColumn, doc, offset) : start,
+    message: input.message,
+    source: input.ruleId ? `eslint:${input.ruleId}` : "eslint",
+    severity: input.severity == 1 ? "warning" : "error"
+  };
+  if (input.fix) {
+    const { range, text } = input.fix, from = range[0] + offset.pos - start, to = range[1] + offset.pos - start;
+    result.actions = [
+      {
+        name: "fix",
+        apply(view, start2) {
+          view.dispatch({
+            changes: { from: start2 + from, to: start2 + to, insert: text },
+            scrollIntoView: true
+          });
+        }
+      }
+    ];
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoCloseTags,
+  completionPath,
+  esLint,
+  javascript,
+  javascriptLanguage,
+  jsxLanguage,
+  localCompletionSource,
+  scopeCompletionSource,
+  snippets,
+  tsxLanguage,
+  typescriptLanguage,
+  typescriptSnippets
+});
+//# sourceMappingURL=index.js.map