@difizen/libro-cofine-editor 0.1.2

package/es/theme/data/libro_light.json

@@ -0,0 +1,170 @@
+{
+  "$schema": "vscode://schemas/color-theme",
+  "name": "libro light",
+  "include": "jupyter-light",
+  "colors": {
+    "activityBar.background": "#ececec",
+    "activityBar.activeBorder": "#000000",
+    "activityBar.foreground": "#000000"
+  },
+  "tokenColors": [
+    {
+      "scope": "storage.type.function",
+      "settings": {
+        "foreground": "#098658",
+        "fontStyle": "bold"
+      }
+    },
+    {
+      "scope": "support.function.builtin.python",
+      "settings": {
+        "foreground": "#098658"
+      }
+    },
+    {
+      "scope": "comment.line.number-sign.python",
+      "settings": {
+        "foreground": "#6A8B93",
+        "fontStyle": "italic"
+      }
+    },
+    {
+      "scope": "keyword.control",
+      "settings": {
+        "foreground": "#098658",
+        "fontStyle": "bold"
+      }
+    },
+    {
+      "scope": "keyword.operator",
+      "settings": {
+        "foreground": "#c700c7"
+      }
+    },
+    {
+      "scope": "meta.member.access",
+      "settings": {
+        "foreground": "#2060a0"
+      }
+    },
+    {
+      "scope": "constant.language",
+      "settings": {
+        "foreground": "#098658",
+        "fontStyle": "bold"
+      }
+    },
+    {
+      "scope": "string.quoted",
+      "settings": {
+        "foreground": "#c03030"
+      }
+    },
+    {
+      "scope": "entity.name.function",
+      "settings": {
+        "foreground": "#003cff"
+      }
+    },
+
+    {
+      "name": "SQL Scope",
+      "scope": ["keywords", "customKeywords"],
+      "settings": {
+        "foreground": "#236fd9"
+      }
+    },
+    {
+      "name": "SQL Scope",
+      "scope": ["comment"],
+      "settings": {
+        "foreground": "#999999"
+      }
+    },
+    {
+      "name": "SQL Scope",
+      "scope": ["builtinFunctions", "function"],
+      "settings": {
+        "foreground": "#CB3BC1"
+      }
+    },
+    {
+      "name": "SQL Scope",
+      "scope": ["operator"],
+      "settings": {
+        "foreground": "#232226"
+      }
+    },
+    {
+      "name": "SQL Scope",
+      "scope": ["string"],
+      "settings": {
+        "foreground": "#D45E00"
+      }
+    },
+    {
+      "name": "SQL Scope",
+      "scope": ["number"],
+      "settings": {
+        "foreground": "#2E7F01"
+      }
+    },
+    {
+      "name": "SQL Scope",
+      "scope": ["variable"],
+      "settings": {
+        "foreground": "#B8DBA6"
+      }
+    },
+    {
+      "name": "Log Scope",
+      "scope": ["log-info"],
+      "settings": {
+        "foreground": "#008800"
+      }
+    },
+    {
+      "name": "Log Scope",
+      "scope": ["log-alert"],
+      "settings": {
+        "foreground": "#DE9504"
+      }
+    },
+    {
+      "name": "Log Scope",
+      "scope": ["log-date"],
+      "settings": {
+        "foreground": "#171617"
+      }
+    },
+    {
+      "name": "Log Scope",
+      "scope": ["log-error"],
+      "settings": {
+        "foreground": "#FF4B61"
+      }
+    },
+    {
+      "name": "Log Scope",
+      "scope": ["log-links"],
+      "settings": {
+        "foreground": "#1292FF"
+      }
+    },
+    {
+      "name": "Log Scope",
+      "scope": ["log-failed"],
+      "settings": {
+        "foreground": "#FF4B61"
+      }
+    },
+    {
+      "name": "Log Scope",
+      "scope": ["log-success"],
+      "settings": {
+        "foreground": "#171617"
+      }
+    }
+  ],
+  "semanticHighlighting": true
+}

package/es/theme/libro-python-theme-contribution.d.ts

@@ -0,0 +1,6 @@
+import type { ThemeRegistry } from '@difizen/libro-cofine-editor-core';
+import { ThemeContribution } from '@difizen/libro-cofine-editor-core';
+export declare class LibroPythonThemeContribution implements ThemeContribution {
+    registerItem(registry: ThemeRegistry): void;
+}
+//# sourceMappingURL=libro-python-theme-contribution.d.ts.map

package/es/theme/libro-python-theme-contribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libro-python-theme-contribution.d.ts","sourceRoot":"","sources":["../../src/theme/libro-python-theme-contribution.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAUtE,qBACa,4BAA6B,YAAW,iBAAiB;IACpE,YAAY,CAAC,QAAQ,EAAE,aAAa,GAAG,IAAI;CAqB5C"}

package/es/theme/libro-python-theme-contribution.js

@@ -0,0 +1,49 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+var _dec, _class;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/* eslint-disable global-require */
+
+import { ThemeContribution } from '@difizen/libro-cofine-editor-core';
+import { singleton } from '@difizen/mana-app';
+import jupyterDark from "./data/jupyter_dark.json";
+import jupyterHCDark from "./data/jupyter_hc_dark.json";
+import jupyterHCLight from "./data/jupyter_hc_light.json";
+import jupyterLight from "./data/jupyter_light.json";
+import libroDark from "./data/libro_dark.json";
+import libroLight from "./data/libro_light.json";
+export var LibroPythonThemeContribution = (_dec = singleton({
+  contrib: ThemeContribution
+}), _dec(_class = /*#__PURE__*/function () {
+  function LibroPythonThemeContribution() {
+    _classCallCheck(this, LibroPythonThemeContribution);
+  }
+  _createClass(LibroPythonThemeContribution, [{
+    key: "registerItem",
+    value: function registerItem(registry) {
+      if (!registry.mixedThemeEnable) {
+        console.warn('cannot register textmate themes');
+        return;
+      }
+
+      // theme名称必须满足 ^[a-z0-9\-]+$， 必须提供base theme
+      // jupyter theme from https://github.com/sam-the-programmer/vscode-jupyter-theme
+      registry.registerMixedTheme(jupyterLight, 'jupyter-light', 'vs');
+      registry.registerMixedTheme(jupyterDark, 'jupyter-dark', 'vs-dark');
+      registry.registerMixedTheme(jupyterHCLight, 'jupyter-hc-light', 'hc-black');
+      registry.registerMixedTheme(jupyterHCDark, 'jupyter-hc-dark', 'hc-black');
+
+      /**
+       * libro theme based on jupyter theme, 支持python;
+       * 同时兼容sql和log, 如果有其他语言需要支持，需要在主题中指定对应的token和颜色;
+       * monaco不同编辑器实例无法使用不同的主题，所有的编辑器实例共享一个主题，后创建的编辑器会覆盖更新全局的主题，所以libro所有e2编辑器必须使用同一个主题!
+       */
+      registry.registerMixedTheme(libroLight, 'libro-light', 'vs');
+      registry.registerMixedTheme(libroDark, 'libro-dark', 'vs-dark');
+    }
+  }]);
+  return LibroPythonThemeContribution;
+}()) || _class);

package/es/theme/module.d.ts

@@ -0,0 +1,2 @@
+export declare const LibroE2ThemeModule: import("@difizen/mana-app").SyringeModule<import("@difizen/mana-app").Syringe.Module>;
+//# sourceMappingURL=module.d.ts.map

package/es/theme/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/theme/module.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,kBAAkB,uFAAkD,CAAC"}

package/es/theme/module.js

@@ -0,0 +1,3 @@
+import { Module } from '@difizen/mana-app';
+import { LibroPythonThemeContribution } from "./libro-python-theme-contribution.js";
+export var LibroE2ThemeModule = Module().register(LibroPythonThemeContribution);

package/es/types.d.ts

@@ -0,0 +1,10 @@
+import { Range, Uri } from '@difizen/monaco-editor-core';
+import type monaco from '@difizen/monaco-editor-core';
+export type MonacoEditorType = monaco.editor.IStandaloneCodeEditor;
+export type MonacoEditorOptions = monaco.editor.IStandaloneEditorConstructionOptions & {
+    uri?: monaco.Uri;
+};
+export type MonacoMatch = monaco.editor.FindMatch;
+export declare const MonacoRange: typeof Range;
+export declare const MonacoUri: typeof Uri;
+//# sourceMappingURL=types.d.ts.map

package/es/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,6BAA6B,CAAC;AACzD,OAAO,KAAK,MAAM,MAAM,6BAA6B,CAAC;AAEtD,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC;AACnE,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,oCAAoC,GAAG;IACrF,GAAG,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC;CAClB,CAAC;AACF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC;AAElD,eAAO,MAAM,WAAW,cAAQ,CAAC;AACjC,eAAO,MAAM,SAAS,YAAM,CAAC"}

package/es/types.js

@@ -0,0 +1,3 @@
+import { Range, Uri } from '@difizen/monaco-editor-core';
+export var MonacoRange = Range;
+export var MonacoUri = Uri;

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@difizen/libro-cofine-editor",
+  "version": "0.1.2",
+  "description": "",
+  "keywords": [
+    "libro",
+    "notebook"
+  ],
+  "repository": "git@github.com:difizen/libro.git",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "typings": "./es/index.d.ts",
+      "default": "./es/index.js"
+    },
+    "./mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./es/mock": {
+      "typings": "./es/mock/index.d.ts",
+      "default": "./es/mock/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "es/index.js",
+  "module": "es/index.js",
+  "typings": "es/index.d.ts",
+  "files": [
+    "es",
+    "src"
+  ],
+  "dependencies": {
+    "@difizen/monaco-editor-core": "latest",
+    "@difizen/libro-cofine-editor-core": "^0.1.2",
+    "@difizen/libro-cofine-textmate": "^0.1.2",
+    "@difizen/libro-lsp": "^0.1.2",
+    "@difizen/libro-code-editor": "^0.1.2",
+    "@difizen/libro-common": "^0.1.2",
+    "@difizen/libro-core": "^0.1.2",
+    "@difizen/mana-app": "latest",
+    "resize-observer-polyfill": "^1.5.1",
+    "vscode-languageserver-protocol": "^3.17.4",
+    "uuid": "^9.0.0"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.25",
+    "@types/uuid": "^9.0.2"
+  },
+  "scripts": {
+    "setup": "father build",
+    "build": "father build",
+    "test": ": Note: lint task is delegated to test:* scripts",
+    "test:vitest": "vitest run",
+    "test:jest": "jest",
+    "coverage": ": Note: lint task is delegated to coverage:* scripts",
+    "coverage:vitest": "vitest run --coverage",
+    "coverage:jest": "jest --coverage",
+    "lint": ": Note: lint task is delegated to lint:* scripts",
+    "lint:eslint": "eslint src",
+    "lint:tsc": "tsc --noEmit"
+  }
+}

package/src/editor-contribution.ts

@@ -0,0 +1,30 @@
+import type { CodeEditorFactory } from '@difizen/libro-code-editor';
+import { CodeEditorContribution } from '@difizen/libro-code-editor';
+import { inject, singleton } from '@difizen/mana-app';
+
+import { libroE2DefaultConfig, LibroE2EditorFactory } from './libro-e2-editor.js';
+
+@singleton({ contrib: [CodeEditorContribution] })
+export class LibroE2EditorContribution implements CodeEditorContribution {
+  factory: CodeEditorFactory;
+
+  defaultConfig = libroE2DefaultConfig;
+
+  constructor(
+    @inject(LibroE2EditorFactory) libroE2EditorFactory: LibroE2EditorFactory,
+  ) {
+    this.factory = libroE2EditorFactory;
+  }
+
+  canHandle(mime: string): number {
+    const mimes = [
+      'application/vnd.libro.sql+json',
+      'text/x-python',
+      'application/vnd.libro.prompt+json',
+    ];
+    if (mimes.includes(mime)) {
+      return 50 + 1;
+    }
+    return 0;
+  }
+}

package/src/index.less

@@ -0,0 +1,32 @@
+.libro-e2-editor-container {
+  padding: 12px 0 18px;
+  background: var(--mana-libro-input-background) !important;
+  border-radius: 4px;
+}
+
+.libro-e2-editor {
+  background: var(--mana-libro-input-background) !important;
+
+  .monaco-editor-background,
+  .margin {
+    background: var(--mana-libro-input-background) !important;
+  }
+
+  .current-line-margin,
+  .current-line-both {
+    background: var(--mana-libro-editor-activeline-color) !important;
+    border: unset !important;
+  }
+
+  .line-numbers {
+    margin-left: 8px;
+    color: var(--mana-libro-editor-gutter-number-color) !important;
+    font-weight: 400;
+    font-size: 13px;
+    // font-family: Menlo-Regular, consolas, 'DejaVu Sans Mono', monospace !important;
+  }
+
+  .cursors-layer .cursor {
+    background-color: var(--mana-libro-editor-cursor-color);
+  }
+}

package/src/index.spec.ts

@@ -0,0 +1,8 @@
+import 'reflect-metadata';
+import assert from 'assert';
+
+describe('libro-cofine-editor', () => {
+  it('#import', () => {
+    assert(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './editor-contribution.js';
+export * from './language-specs.js';
+export * from './libro-e2-editor.js';
+export * from './libro-e2-preload.js';
+export * from './libro-sql-api.js';
+export * from './module.js';

package/src/language/lsp/completion-provider.ts

@@ -0,0 +1,214 @@
+import { CompletionTriggerKind } from '@difizen/libro-lsp';
+import { languages } from '@difizen/monaco-editor-core';
+import type monaco from '@difizen/monaco-editor-core';
+import * as lsp from 'vscode-languageserver-protocol';
+import { InsertReplaceEdit } from 'vscode-languageserver-protocol';
+
+import { LangaugeFeatureProvider } from './language-feature-provider.js';
+import { CompletionItemKind } from './type-concerters.js';
+
+export class CompletionProvider
+  extends LangaugeFeatureProvider
+  implements monaco.languages.CompletionItemProvider
+{
+  triggerCharacters: ['.', '[', '"', "'"];
+
+  public provideCompletionItems = async (
+    model: monaco.editor.ITextModel,
+    position: monaco.Position,
+  ): Promise<monaco.languages.CompletionList | undefined> => {
+    const result = await this.provideCompletionItemsFromLSPServer(model, position);
+    return result;
+  };
+
+  protected provideCompletionItemsFromKernel = async (
+    model: monaco.editor.ITextModel,
+    position: monaco.Position,
+  ): Promise<monaco.languages.CompletionList | undefined> => {
+    const editor = this.getEditorByModel(model);
+    if (!editor || editor.getOption('lspEnabled') !== true) {
+      return;
+    }
+
+    const reply = await editor.completionProvider?.({
+      cursorPosition: editor.getOffsetAt({
+        column: position.column,
+        line: position.lineNumber,
+      }),
+    });
+
+    const start = reply?.cursor_start
+      ? editor.getPositionAt(reply?.cursor_start)
+      : editor.getCursorPosition();
+    const end = reply?.cursor_end
+      ? editor.getPositionAt(reply?.cursor_end)
+      : editor.getCursorPosition();
+
+    const suggestion: languages.CompletionItem[] = (reply?.matches ?? []).map(
+      (match) => {
+        return {
+          label: match,
+          kind: languages.CompletionItemKind.Text,
+          insertText: match,
+          range: {
+            startColumn: start?.column,
+            startLineNumber: start?.line,
+            endColumn: end?.column,
+            endLineNumber: end?.line,
+          },
+        } as languages.CompletionItem;
+      },
+    );
+
+    return {
+      suggestions: suggestion as any,
+    };
+  };
+
+  protected provideCompletionItemsFromLSPServer = async (
+    model: monaco.editor.ITextModel,
+    position: monaco.Position,
+  ): Promise<monaco.languages.CompletionList | undefined> => {
+    const provider = await this.getProvider(model);
+    if (!provider) {
+      return;
+    }
+    const editor = this.getEditorByModel(model);
+    if (!editor || editor.getOption('lspEnabled') !== true) {
+      return;
+    }
+
+    const { lspConnection, editor: docEditor, virtualDocument: doc } = provider;
+
+    if (!lspConnection.isReady || !lspConnection.provides('completionProvider')) {
+      return;
+    }
+
+    const virtualPos = doc.transformEditorToVirtual(docEditor, {
+      line: position.lineNumber - 1,
+      ch: position.column,
+      isEditor: true,
+    });
+
+    if (!virtualPos) {
+      return;
+    }
+
+    const result = await lspConnection.clientRequests[
+      'textDocument/completion'
+    ].request({
+      position: { line: virtualPos.line, character: virtualPos.ch },
+      textDocument: {
+        uri: doc.documentInfo.uri,
+      },
+      context: {
+        triggerKind: CompletionTriggerKind.Invoked,
+      },
+    });
+
+    const items = 'items' in result ? result.items : result;
+
+    const word = model.getWordUntilPosition(position);
+    const range = {
+      startLineNumber: position.lineNumber,
+      endLineNumber: position.lineNumber,
+      startColumn: word.startColumn,
+      endColumn: position.column,
+    };
+
+    const suggestions: monaco.languages.CompletionItem[] = items.map(
+      (item: lsp.CompletionItem) => {
+        return this.transformCompletion(item, range);
+      },
+    );
+
+    if (Array.isArray(result)) {
+      return { suggestions };
+    }
+
+    return {
+      incomplete: result.isIncomplete,
+      suggestions,
+    };
+  };
+
+  resolveCompletionItem = async (
+    item: monaco.languages.CompletionItem,
+    token: monaco.CancellationToken,
+  ): Promise<monaco.languages.CompletionItem | undefined> => {
+    const original = (item as any).__original as lsp.CompletionItem | undefined;
+    if (!original) {
+      return;
+    }
+    const itemResult =
+      await this.lspConnection.clientRequests['completionItem/resolve'].request(
+        original,
+      );
+    if (token.isCancellationRequested) {
+      return;
+    }
+    const resolve = this.transformCompletion(itemResult, item.range);
+    return resolve;
+  };
+
+  transformCompletion(
+    item: lsp.CompletionItem,
+    range: monaco.IRange | monaco.languages.CompletionItemRanges,
+  ): monaco.languages.CompletionItem {
+    const converted: monaco.languages.CompletionItem = {
+      ...item,
+      label: item.label,
+      sortText: item.sortText,
+      filterText: item.filterText,
+      insertText: item.insertText ? item.insertText : item.label,
+      kind: CompletionItemKind.from(item.kind ?? lsp.CompletionItemKind.Property),
+      detail: item.detail,
+      documentation: item.documentation,
+      command: item.command
+        ? {
+            id: item.command.command,
+            title: item.command.title,
+            arguments: item.command?.arguments,
+          }
+        : undefined,
+      range,
+      additionalTextEdits: undefined,
+    };
+
+    // FIXME: text edit 生成的range有可能在其他的editor上,这里似乎无法处理
+    if (item.textEdit) {
+      converted.insertText = item.textEdit.newText;
+      if (InsertReplaceEdit.is(item.textEdit)) {
+        converted.range = {
+          insert: convertRange(item.textEdit.insert),
+          replace: convertRange(item.textEdit.replace),
+        };
+      } else {
+        converted.range = convertRange(item.textEdit.range);
+      }
+    }
+
+    if (item.additionalTextEdits) {
+      converted.additionalTextEdits = item.additionalTextEdits.map((edit) => {
+        return {
+          range: convertRange(edit.range),
+          text: edit.newText,
+        };
+      });
+    }
+
+    // Stash a few additional pieces of information.
+    (converted as any).__original = item;
+
+    return converted;
+  }
+}
+
+function convertRange(range: lsp.Range): monaco.IRange {
+  return {
+    startLineNumber: range.start.line + 1,
+    startColumn: range.start.character + 1,
+    endLineNumber: range.end.line + 1,
+    endColumn: range.end.character + 1,
+  };
+}