@difizen/libro-cofine-editor-contribution 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Difizen Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# libro-notebook
+
+cell

package/es/editor-options-registry.d.ts

@@ -0,0 +1,7 @@
+import type monaco from '@difizen/monaco-editor-core';
+export declare class EditorOptionsRegistry {
+    protected optionsMap: Map<monaco.Uri, any>;
+    set(uri: monaco.Uri, data: any): void;
+    get(uri: monaco.Uri): any;
+}
+//# sourceMappingURL=editor-options-registry.d.ts.map

package/es/editor-options-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-options-registry.d.ts","sourceRoot":"","sources":["../src/editor-options-registry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,6BAA6B,CAAC;AAEtD,qBACa,qBAAqB;IAChC,SAAS,CAAC,UAAU,uBAA8B;IAElD,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,GAAG;IAI9B,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG;CAGpB"}

package/es/editor-options-registry.js

@@ -0,0 +1,26 @@
+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); }
+import { singleton } from '@difizen/mana-app';
+export var EditorOptionsRegistry = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function EditorOptionsRegistry() {
+    _classCallCheck(this, EditorOptionsRegistry);
+    this.optionsMap = new Map();
+  }
+  _createClass(EditorOptionsRegistry, [{
+    key: "set",
+    value: function set(uri, data) {
+      this.optionsMap.set(uri, data);
+    }
+  }, {
+    key: "get",
+    value: function get(uri) {
+      return this.optionsMap.get(uri);
+    }
+  }]);
+  return EditorOptionsRegistry;
+}()) || _class);

package/es/index.d.ts

@@ -0,0 +1,14 @@
+import type { Disposable } from '@difizen/mana-app';
+import { Syringe } from '@difizen/mana-app';
+import type monaco from '@difizen/monaco-editor-core';
+export declare const EditorHandlerContribution: Syringe.DefinedToken;
+export interface EditorHandlerContribution extends Disposable {
+    beforeCreate: (coreMonaco: typeof monaco) => void;
+    afterCreate: (editor: monaco.editor.IStandaloneCodeEditor | monaco.editor.IStandaloneDiffEditor, coreMonaco: typeof monaco) => void;
+    canHandle: (language: string) => boolean;
+}
+export { EditorOptionsRegistry } from './editor-options-registry.js';
+export { LanguageWorkerContribution, LanguageWorkerRegistry, } from './language-worker-registry.js';
+export { LazyLoaderRegistry, LazyLoaderRegistryContribution, } from './lazy-loader-registry.js';
+export { LanguageOptionsRegistry } from './options-registry.js';
+//# sourceMappingURL=index.d.ts.map

package/es/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC5C,OAAO,KAAK,MAAM,MAAM,6BAA6B,CAAC;AAEtD,eAAO,MAAM,yBAAyB,sBAErC,CAAC;AAEF,MAAM,WAAW,yBAA0B,SAAQ,UAAU;IAC3D,YAAY,EAAE,CAAC,UAAU,EAAE,OAAO,MAAM,KAAK,IAAI,CAAC;IAClD,WAAW,EAAE,CACX,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,qBAAqB,EACjF,UAAU,EAAE,OAAO,MAAM,KACtB,IAAI,CAAC;IACV,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC;CAC1C;AACD,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EACL,0BAA0B,EAC1B,sBAAsB,GACvB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,kBAAkB,EAClB,8BAA8B,GAC/B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC"}

package/es/index.js

@@ -0,0 +1,6 @@
+import { Syringe } from '@difizen/mana-app';
+export var EditorHandlerContribution = Syringe.defineToken('LanguageWorkerContribution');
+export { EditorOptionsRegistry } from "./editor-options-registry.js";
+export { LanguageWorkerContribution, LanguageWorkerRegistry } from "./language-worker-registry.js";
+export { LazyLoaderRegistry, LazyLoaderRegistryContribution } from "./lazy-loader-registry.js";
+export { LanguageOptionsRegistry } from "./options-registry.js";

package/es/language-worker-registry.d.ts

@@ -0,0 +1,20 @@
+import type { Contribution } from '@difizen/mana-app';
+import { Syringe } from '@difizen/mana-app';
+export declare const LanguageWorkerContribution: Syringe.DefinedToken;
+export interface LanguageWorkerContribution {
+    registerLanguageWorkers: (registry: LanguageWorkerRegistry) => void;
+}
+export interface LanguageWorkerConfig {
+    language: string;
+    priority?: number;
+    getWorkerUrl: (language: string, moduleId?: string) => string;
+}
+export declare class LanguageWorkerRegistry {
+    protected configs: LanguageWorkerConfig[];
+    protected readonly provider: Contribution.Provider<LanguageWorkerContribution>;
+    constructor(provider: Contribution.Provider<LanguageWorkerContribution>);
+    registerWorker(config: LanguageWorkerConfig): void;
+    getLanguageWorker(language: string, moduleId?: string): string | undefined;
+    getLanguageConfig(language: string): LanguageWorkerConfig | undefined;
+}
+//# sourceMappingURL=language-worker-registry.d.ts.map

package/es/language-worker-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-worker-registry.d.ts","sourceRoot":"","sources":["../src/language-worker-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAsB,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEhE,eAAO,MAAM,0BAA0B,sBAEtC,CAAC;AACF,MAAM,WAAW,0BAA0B;IACzC,uBAAuB,EAAE,CAAC,QAAQ,EAAE,sBAAsB,KAAK,IAAI,CAAC;CACrE;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC/D;AAED,qBACa,sBAAsB;IACjC,SAAS,CAAC,OAAO,EAAE,oBAAoB,EAAE,CAAM;IAC/C,SAAS,CAAC,QAAQ,CAAC,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,0BAA0B,CAAC,CAAC;gBAG7E,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,0BAA0B,CAAC;IAQ7D,cAAc,CAAC,MAAM,EAAE,oBAAoB;IAiB3C,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAW1E,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS;CAKtE"}

package/es/language-worker-registry.js

@@ -0,0 +1,72 @@
+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 _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+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); }
+import { contrib, singleton, Syringe } from '@difizen/mana-app';
+export var LanguageWorkerContribution = Syringe.defineToken('LanguageWorkerContribution');
+export var LanguageWorkerRegistry = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function LanguageWorkerRegistry(provider) {
+    var _this = this;
+    _classCallCheck(this, LanguageWorkerRegistry);
+    this.configs = [];
+    this.provider = provider;
+    this.provider.getContributions().forEach(function (contribution) {
+      contribution.registerLanguageWorkers(_this);
+    });
+  }
+  LanguageWorkerRegistry = contrib(LanguageWorkerContribution)(LanguageWorkerRegistry, undefined, 0) || LanguageWorkerRegistry;
+  _createClass(LanguageWorkerRegistry, [{
+    key: "registerWorker",
+    value: function registerWorker(config) {
+      var conf = _objectSpread(_objectSpread({}, config), {}, {
+        language: config.language.toUpperCase()
+      });
+      if (this.configs.find(function (c) {
+        return c.language === conf.language;
+      })) {
+        console.warn("Language ".concat(conf.language, " has already registed, this will overwrite the previous configuration"));
+      }
+      this.configs = [].concat(_toConsumableArray(this.configs), [conf]).sort(function (a, b) {
+        var aPriority = a.priority || 100;
+        var bPriority = b.priority || 100;
+        return bPriority - aPriority;
+      });
+    }
+  }, {
+    key: "getLanguageWorker",
+    value: function getLanguageWorker(language, moduleId) {
+      var _this2 = this;
+      this.configs = [];
+      this.provider.getContributions({
+        cache: false
+      }).forEach(function (contribution) {
+        contribution.registerLanguageWorkers(_this2);
+      });
+      var config = this.getLanguageConfig(language);
+      if (config) {
+        return config.getWorkerUrl(language, moduleId);
+      }
+      return undefined;
+    }
+  }, {
+    key: "getLanguageConfig",
+    value: function getLanguageConfig(language) {
+      return this.configs.find(function (item) {
+        return item.language.toUpperCase() === language.toUpperCase();
+      });
+    }
+  }]);
+  return LanguageWorkerRegistry;
+}()) || _class);

package/es/lazy-loader-registry.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Contribution } from '@difizen/mana-app';
+import { Syringe } from '@difizen/mana-app';
+export declare const LazyLoaderRegistryContribution: Syringe.DefinedToken;
+export interface LazyLoaderRegistryContribution extends Disposable {
+    handleLazyLoder: () => void;
+    isLazyLoader?: boolean;
+}
+export declare class LazyLoaderRegistry {
+    provider: Contribution.Provider<LazyLoaderRegistryContribution>;
+    constructor(provider: Contribution.Provider<LazyLoaderRegistryContribution>);
+    handleLazyLoder(): void;
+}
+//# sourceMappingURL=lazy-loader-registry.d.ts.map

package/es/lazy-loader-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy-loader-registry.d.ts","sourceRoot":"","sources":["../src/lazy-loader-registry.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAsB,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEhE,eAAO,MAAM,8BAA8B,sBAE1C,CAAC;AACF,MAAM,WAAW,8BAA+B,SAAQ,UAAU;IAChE,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,qBACa,kBAAkB;IAC7B,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,8BAA8B,CAAC,CAAC;gBAG9D,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,8BAA8B,CAAC;IAIjE,eAAe;CAQhB"}

package/es/lazy-loader-registry.js

@@ -0,0 +1,30 @@
+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); }
+import { contrib, singleton, Syringe } from '@difizen/mana-app';
+export var LazyLoaderRegistryContribution = Syringe.defineToken('LazyLoaderRegistryContribution');
+export var LazyLoaderRegistry = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function LazyLoaderRegistry(provider) {
+    _classCallCheck(this, LazyLoaderRegistry);
+    this.provider = provider;
+  }
+  LazyLoaderRegistry = contrib(LazyLoaderRegistryContribution)(LazyLoaderRegistry, undefined, 0) || LazyLoaderRegistry;
+  _createClass(LazyLoaderRegistry, [{
+    key: "handleLazyLoder",
+    value: function handleLazyLoder() {
+      this.provider.getContributions({
+        cache: false
+      }).forEach(function (c) {
+        if (c.isLazyLoader) {
+          return;
+        }
+        c.handleLazyLoder();
+      });
+    }
+  }]);
+  return LazyLoaderRegistry;
+}()) || _class);

package/es/options-registry.d.ts

@@ -0,0 +1,6 @@
+export declare class LanguageOptionsRegistry {
+    protected optionsMap: Map<string, any>;
+    registerOptions(key: string, data: any): void;
+    getOptions(key: string): any;
+}
+//# sourceMappingURL=options-registry.d.ts.map

package/es/options-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options-registry.d.ts","sourceRoot":"","sources":["../src/options-registry.ts"],"names":[],"mappings":"AAEA,qBACa,uBAAuB;IAClC,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAa;IAEnD,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG;IAItC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;CAG7B"}

package/es/options-registry.js

@@ -0,0 +1,26 @@
+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); }
+import { singleton } from '@difizen/mana-app';
+export var LanguageOptionsRegistry = (_dec = singleton(), _dec(_class = /*#__PURE__*/function () {
+  function LanguageOptionsRegistry() {
+    _classCallCheck(this, LanguageOptionsRegistry);
+    this.optionsMap = new Map();
+  }
+  _createClass(LanguageOptionsRegistry, [{
+    key: "registerOptions",
+    value: function registerOptions(key, data) {
+      this.optionsMap.set(key, data);
+    }
+  }, {
+    key: "getOptions",
+    value: function getOptions(key) {
+      return this.optionsMap.get(key);
+    }
+  }]);
+  return LanguageOptionsRegistry;
+}()) || _class);

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@difizen/libro-cofine-editor-contribution",
+  "version": "0.1.2",
+  "description": "",
+  "keywords": [
+    "libro",
+    "notebook",
+    "monaco"
+  ],
+  "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/mana-app": "latest"
+  },
+  "devDependencies": {
+    "@difizen/monaco-editor-core": "latest"
+  },
+  "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-options-registry.ts

@@ -0,0 +1,15 @@
+import { singleton } from '@difizen/mana-app';
+import type monaco from '@difizen/monaco-editor-core';
+
+@singleton()
+export class EditorOptionsRegistry {
+  protected optionsMap = new Map<monaco.Uri, any>();
+
+  set(uri: monaco.Uri, data: any) {
+    this.optionsMap.set(uri, data);
+  }
+
+  get(uri: monaco.Uri) {
+    return this.optionsMap.get(uri);
+  }
+}

package/src/index.spec.ts

@@ -0,0 +1,10 @@
+import 'reflect-metadata';
+import assert from 'assert';
+
+import { LanguageWorkerContribution } from './index.js';
+
+describe('libro-cofine-editor-contribution', () => {
+  it('#import', () => {
+    assert(LanguageWorkerContribution);
+  });
+});

package/src/index.ts

@@ -0,0 +1,26 @@
+import type { Disposable } from '@difizen/mana-app';
+import { Syringe } from '@difizen/mana-app';
+import type monaco from '@difizen/monaco-editor-core';
+
+export const EditorHandlerContribution = Syringe.defineToken(
+  'LanguageWorkerContribution',
+);
+
+export interface EditorHandlerContribution extends Disposable {
+  beforeCreate: (coreMonaco: typeof monaco) => void;
+  afterCreate: (
+    editor: monaco.editor.IStandaloneCodeEditor | monaco.editor.IStandaloneDiffEditor,
+    coreMonaco: typeof monaco,
+  ) => void;
+  canHandle: (language: string) => boolean;
+}
+export { EditorOptionsRegistry } from './editor-options-registry.js';
+export {
+  LanguageWorkerContribution,
+  LanguageWorkerRegistry,
+} from './language-worker-registry.js';
+export {
+  LazyLoaderRegistry,
+  LazyLoaderRegistryContribution,
+} from './lazy-loader-registry.js';
+export { LanguageOptionsRegistry } from './options-registry.js';

package/src/language-worker-registry.ts

@@ -0,0 +1,64 @@
+import type { Contribution } from '@difizen/mana-app';
+import { contrib, singleton, Syringe } from '@difizen/mana-app';
+
+export const LanguageWorkerContribution = Syringe.defineToken(
+  'LanguageWorkerContribution',
+);
+export interface LanguageWorkerContribution {
+  registerLanguageWorkers: (registry: LanguageWorkerRegistry) => void;
+}
+
+export interface LanguageWorkerConfig {
+  language: string;
+  priority?: number;
+  getWorkerUrl: (language: string, moduleId?: string) => string;
+}
+
+@singleton()
+export class LanguageWorkerRegistry {
+  protected configs: LanguageWorkerConfig[] = [];
+  protected readonly provider: Contribution.Provider<LanguageWorkerContribution>;
+  constructor(
+    @contrib(LanguageWorkerContribution)
+    provider: Contribution.Provider<LanguageWorkerContribution>,
+  ) {
+    this.provider = provider;
+    this.provider.getContributions().forEach((contribution) => {
+      contribution.registerLanguageWorkers(this);
+    });
+  }
+
+  registerWorker(config: LanguageWorkerConfig) {
+    const conf = {
+      ...config,
+      language: config.language.toUpperCase(),
+    };
+    if (this.configs.find((c) => c.language === conf.language)) {
+      console.warn(
+        `Language ${conf.language} has already registed, this will overwrite the previous configuration`,
+      );
+    }
+    this.configs = [...this.configs, conf].sort((a, b) => {
+      const aPriority = a.priority || 100;
+      const bPriority = b.priority || 100;
+      return bPriority - aPriority;
+    });
+  }
+
+  getLanguageWorker(language: string, moduleId?: string): string | undefined {
+    this.configs = [];
+    this.provider.getContributions({ cache: false }).forEach((contribution) => {
+      contribution.registerLanguageWorkers(this);
+    });
+    const config = this.getLanguageConfig(language);
+    if (config) {
+      return config.getWorkerUrl(language, moduleId);
+    }
+    return undefined;
+  }
+  getLanguageConfig(language: string): LanguageWorkerConfig | undefined {
+    return this.configs.find(
+      (item) => item.language.toUpperCase() === language.toUpperCase(),
+    );
+  }
+}

package/src/lazy-loader-registry.ts

@@ -0,0 +1,29 @@
+import type { Contribution } from '@difizen/mana-app';
+import { contrib, singleton, Syringe } from '@difizen/mana-app';
+
+export const LazyLoaderRegistryContribution = Syringe.defineToken(
+  'LazyLoaderRegistryContribution',
+);
+export interface LazyLoaderRegistryContribution extends Disposable {
+  handleLazyLoder: () => void;
+  isLazyLoader?: boolean;
+}
+
+@singleton()
+export class LazyLoaderRegistry {
+  provider: Contribution.Provider<LazyLoaderRegistryContribution>;
+  constructor(
+    @contrib(LazyLoaderRegistryContribution)
+    provider: Contribution.Provider<LazyLoaderRegistryContribution>,
+  ) {
+    this.provider = provider;
+  }
+  handleLazyLoder() {
+    this.provider.getContributions({ cache: false }).forEach((c) => {
+      if (c.isLazyLoader) {
+        return;
+      }
+      c.handleLazyLoder();
+    });
+  }
+}

package/src/options-registry.ts

@@ -0,0 +1,14 @@
+import { singleton } from '@difizen/mana-app';
+
+@singleton()
+export class LanguageOptionsRegistry {
+  protected optionsMap: Map<string, any> = new Map();
+
+  registerOptions(key: string, data: any) {
+    this.optionsMap.set(key, data);
+  }
+
+  getOptions(key: string): any {
+    return this.optionsMap.get(key);
+  }
+}