@difizen/libro-cofine-editor 0.1.2

package/src/language/python/python-language-feature.ts

@@ -0,0 +1,163 @@
+import type { SnippetSuggestRegistry } from '@difizen/libro-cofine-editor-core';
+import {
+  InitializeContribution,
+  LanguageOptionsRegistry,
+  SnippetSuggestContribution,
+} from '@difizen/libro-cofine-editor-core';
+import type {
+  GrammarDefinition,
+  TextmateRegistry,
+} from '@difizen/libro-cofine-textmate';
+import { LanguageGrammarDefinitionContribution } from '@difizen/libro-cofine-textmate';
+import { inject, singleton } from '@difizen/mana-app';
+import { languages } from '@difizen/monaco-editor-core';
+import * as monaco from '@difizen/monaco-editor-core';
+
+import pythonGrammar from './data/MagicPython.tmLanguage.json';
+import regExpGrammar from './data/MagicRegExp.tmLanguage.json';
+import snippetsJson from './data/snippets/python.snippets.json';
+
+export interface PythonLanguageOption {
+  lspHost: {
+    host: string;
+    path: string;
+  };
+}
+
+export function isPythonLanguageOption(data: object): data is PythonLanguageOption {
+  return data && typeof data === 'object' && 'lspHost' in data;
+}
+
+let langRegisted = false;
+let grammerRegisted = false;
+
+@singleton({
+  contrib: [
+    LanguageGrammarDefinitionContribution,
+    SnippetSuggestContribution,
+    InitializeContribution,
+  ],
+})
+export class PythonContribution
+  implements
+    LanguageGrammarDefinitionContribution,
+    SnippetSuggestContribution,
+    InitializeContribution
+{
+  protected readonly optionsResgistry: LanguageOptionsRegistry;
+
+  readonly id = 'python';
+  readonly config: languages.LanguageConfiguration = {
+    comments: {
+      lineComment: '#',
+    },
+    brackets: [
+      ['{', '}'],
+      ['[', ']'],
+      ['(', ')'],
+    ],
+    autoClosingPairs: [
+      { open: '[', close: ']' },
+      { open: '{', close: '}' },
+      { open: '(', close: ')' },
+      { open: "'", close: "'", notIn: ['string', 'comment'] },
+      { open: '"', close: '"', notIn: ['string'] },
+    ],
+    surroundingPairs: [
+      { open: '{', close: '}' },
+      { open: '[', close: ']' },
+      { open: '(', close: ')' },
+      { open: '"', close: '"' },
+      { open: "'", close: "'" },
+    ],
+    folding: {
+      markers: {
+        start: new RegExp('^\\s*#pragma\\s+region\\b'),
+        end: new RegExp('^\\s*#pragma\\s+endregion\\b'),
+      },
+    },
+    onEnterRules: [
+      {
+        beforeText:
+          /^\s*(?:def|class|for|if|elif|else|while|try|with|finally|except|async).*?:\s*$/,
+        action: { indentAction: languages.IndentAction.Indent },
+      },
+    ],
+  };
+
+  constructor(
+    @inject(LanguageOptionsRegistry) optionsResgistry: LanguageOptionsRegistry,
+  ) {
+    this.optionsResgistry = optionsResgistry;
+  }
+
+  onInitialize() {
+    monaco.languages.register({
+      id: this.id,
+      extensions: [
+        '.py',
+        '.rpy',
+        '.pyw',
+        '.cpy',
+        '.gyp',
+        '.gypi',
+        '.snakefile',
+        '.smk',
+      ],
+      aliases: ['Python', 'py'],
+      firstLine: '^#!\\s*/.*\\bpython[0-9.-]*\\b',
+    });
+    monaco.languages.onLanguage(this.id, () => {
+      this.registerLanguageFeature();
+    });
+  }
+
+  protected registerLanguageFeature() {
+    if (langRegisted) {
+      return;
+    }
+    langRegisted = true;
+    monaco.languages.setLanguageConfiguration(this.id, this.config);
+  }
+
+  registerSnippetSuggest(registry: SnippetSuggestRegistry) {
+    registry.fromJSON(snippetsJson, {
+      language: [this.id],
+      source: 'Python Language',
+    });
+  }
+
+  registerTextmateLanguage(registry: TextmateRegistry): void {
+    if (grammerRegisted) {
+      return;
+    }
+    grammerRegisted = true;
+
+    registry.registerTextmateGrammarScope('source.python', {
+      async getGrammarDefinition(): Promise<GrammarDefinition> {
+        return {
+          format: 'json',
+          content: pythonGrammar,
+        };
+      },
+    });
+
+    registry.registerTextmateGrammarScope('source.regexp.python', {
+      async getGrammarDefinition(): Promise<GrammarDefinition> {
+        return {
+          format: 'json',
+          content: regExpGrammar,
+        };
+      },
+    });
+    registry.mapLanguageIdToTextmateGrammar(this.id, 'source.python');
+  }
+
+  protected isDisposed = false;
+  get disposed() {
+    return this.isDisposed;
+  }
+  dispose() {
+    this.isDisposed = false;
+  }
+}

package/src/language-specs.ts

@@ -0,0 +1,99 @@
+import type { Contribution } from '@difizen/mana-app';
+import { ApplicationContribution } from '@difizen/mana-app';
+import { contrib, inject, singleton, Syringe } from '@difizen/mana-app';
+
+import type { LibroE2Editor, LibroE2EditorConfig } from './libro-e2-editor.js';
+import { LibroSQLRequestAPI } from './libro-sql-api.js';
+
+export const LanguageSpecContribution = Syringe.defineToken('LanguageSpecContribution');
+export interface LanguageSpecContribution {
+  registerLanguageSpec: (register: LanguageSpecRegistry) => void;
+}
+export interface LanguageSpec {
+  name: string;
+  language: string;
+  mime: string;
+  ext: string[];
+  loadModule?: (container: Syringe.Container) => Promise<void>;
+  beforeEditorInit?: () => Promise<void>;
+  editorConfig?: Partial<LibroE2EditorConfig>;
+  afterEditorInit?: (editor: LibroE2Editor) => Promise<void>;
+}
+
+@singleton({ contrib: [ApplicationContribution] })
+export class LanguageSpecRegistry implements ApplicationContribution {
+  get languageSpecs(): LanguageSpec[] {
+    return this.languageSpecsData;
+  }
+  protected languageSpecsData: LanguageSpec[] = [];
+
+  protected readonly languageSpecProvider: Contribution.Provider<LanguageSpecContribution>;
+
+  constructor(
+    @contrib(LanguageSpecContribution)
+    languageSpecProvider: Contribution.Provider<LanguageSpecContribution>,
+  ) {
+    this.languageSpecProvider = languageSpecProvider;
+  }
+
+  initialize() {
+    this.languageSpecProvider.getContributions().forEach((item) => {
+      item.registerLanguageSpec(this);
+    });
+  }
+
+  registerLanguageSpec(spec: LanguageSpec) {
+    const index = this.languageSpecsData.findIndex(
+      (item) => item.language === spec.language,
+    );
+    if (index >= 0) {
+      this.languageSpecsData.splice(index, 1, spec);
+    } else {
+      this.languageSpecsData.push(spec);
+    }
+  }
+
+  hasLanguage(spec: LanguageSpec) {
+    return (
+      this.languageSpecsData.findIndex((item) => item.language === spec.language) > 0
+    );
+  }
+}
+
+@singleton({ contrib: [LanguageSpecContribution] })
+export class LibroLanguageSpecs implements LanguageSpecContribution {
+  @inject(LibroSQLRequestAPI)
+  protected readonly dataphinAPI: LibroSQLRequestAPI;
+
+  registerLanguageSpec = (register: LanguageSpecRegistry) => {
+    register.registerLanguageSpec({
+      name: 'Python',
+      language: 'python',
+      ext: ['.py'],
+      mime: 'text/x-python',
+      editorConfig: {},
+    });
+    register.registerLanguageSpec({
+      name: 'SQL',
+      mime: 'application/vnd.libro.sql+json',
+      language: 'sql-odps',
+      ext: ['.sql'],
+      editorConfig: {},
+      beforeEditorInit: async () => {
+        //
+      },
+    });
+    register.registerLanguageSpec({
+      name: 'Markdown',
+      language: 'markdown',
+      mime: 'text/x-markdown',
+      ext: ['md', 'markdown', 'mkd'],
+    });
+    register.registerLanguageSpec({
+      name: 'Prompt',
+      language: 'markdown',
+      mime: 'application/vnd.libro.prompt+json',
+      ext: ['md', 'markdown', 'mkd'],
+    });
+  };
+}