@univerjs/docs-ui 0.1.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-present, DreamNum
+
+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,16 @@
+# @univerjs/docs-ui
+
+[![npm version](https://img.shields.io/npm/v/@univerjs/docs-ui)](https://npmjs.org/packages/@univerjs/docs-ui)
+[![license](https://img.shields.io/npm/l/@univerjs/docs-ui)](https://img.shields.io/npm/l/@univerjs/docs-ui)
+
+## Introduction
+
+> UI plugin for Univer Docs.
+
+## Usage
+
+### Installation
+
+```shell
+npm i @univerjs/docs-ui
+```

package/lib/cjs/index.js

@@ -0,0 +1,514 @@
+"use strict";
+function _assert_this_initialized(self) {
+    if (self === void 0) {
+        throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    }
+    return self;
+}
+function _class_call_check(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, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) {
+        return call;
+    }
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _is_native_reflect_construct() {
+    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+    if (Reflect.construct.sham) return false;
+    if (typeof Proxy === "function") return true;
+    try {
+        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+function _create_super(Derived) {
+    var hasNativeReflectConstruct = _is_native_reflect_construct();
+    return function _createSuperInternal() {
+        var Super = _get_prototype_of(Derived), result;
+        if (hasNativeReflectConstruct) {
+            var NewTarget = _get_prototype_of(this).constructor;
+            result = Reflect.construct(Super, arguments, NewTarget);
+        } else {
+            result = Super.apply(this, arguments);
+        }
+        return _possible_constructor_return(this, result);
+    };
+}
+var _import_core4_Plugin, _class;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = function(target, all) {
+    for(var name in all)__defProp(target, name, {
+        get: all[name],
+        enumerable: true
+    });
+};
+var __copyProps = function(to, from, except, desc) {
+    if (from && typeof from === "object" || typeof from === "function") {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            var _loop = function() {
+                var key = _step.value;
+                if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+                    get: function() {
+                        return from[key];
+                    },
+                    enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+                });
+            };
+            for(var _iterator = __getOwnPropNames(from)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return to;
+};
+var __toCommonJS = function(mod) {
+    return __copyProps(__defProp({}, "__esModule", {
+        value: true
+    }), mod);
+};
+var __decorateClass = function(decorators, target, key, kind) {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+    for(var i = decorators.length - 1, decorator; i >= 0; i--)if (decorator = decorators[i]) result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+    if (kind && result) __defProp(target, key, result);
+    return result;
+};
+var __decorateParam = function(index, decorator) {
+    return function(target, key) {
+        return decorator(target, key, index);
+    };
+};
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+    DOC_UI_PLUGIN_NAME: function() {
+        return DOC_UI_PLUGIN_NAME;
+    },
+    DefaultDocContainerConfig: function() {
+        return DefaultDocContainerConfig;
+    },
+    DefaultDocUiConfig: function() {
+        return DefaultDocUiConfig;
+    },
+    DefaultToolbarConfig: function() {
+        return DefaultToolbarConfig;
+    },
+    DocsUIPlugin: function() {
+        return DocsUIPlugin;
+    }
+});
+module.exports = __toCommonJS(src_exports);
+// src/basics/const/default-univer-doc-config.ts
+var DefaultToolbarConfig = {
+    undo: true,
+    redo: true,
+    // Undo redo
+    font: true,
+    // 'font'
+    fontSize: true,
+    // 'Font size'
+    bold: true,
+    // 'Bold (Ctrl+B)'
+    italic: true,
+    // 'Italic (Ctrl+I)'
+    strikethrough: true,
+    // 'Strikethrough (Alt+Shift+5)'
+    underline: true,
+    // 'Underline (Alt+Shift+6)'
+    textColor: true,
+    // 'Text color'
+    fillColor: true,
+    // 'Cell color'
+    horizontalAlignMode: true,
+    // 'Horizontal alignment'
+    verticalAlignMode: true,
+    // 'Vertical alignment'
+    textWrapMode: true,
+    // 'Wrap mode'
+    textRotateMode: true
+};
+var DefaultDocContainerConfig = {
+    outerLeft: false,
+    outerRight: false,
+    header: true,
+    footer: true,
+    innerLeft: false,
+    innerRight: false,
+    frozenHeaderLT: false,
+    frozenHeaderRT: false,
+    frozenHeaderLM: false,
+    frozenContent: false,
+    infoBar: true,
+    toolbar: true
+};
+var DefaultDocUiConfig = {
+    layout: {
+        docContainerConfig: DefaultDocContainerConfig,
+        toolbarConfig: DefaultToolbarConfig
+    }
+};
+// src/basics/const/plugin-name.ts
+var DOC_UI_PLUGIN_NAME = "DocUI";
+// src/docs-ui-plugin.ts
+var import_core4 = require("@univerjs/core");
+var import_redi4 = require("@wendellhu/redi");
+// src/controllers/app-ui-controller.ts
+var import_core2 = require("@univerjs/core");
+var import_redi2 = require("@wendellhu/redi");
+// src/controllers/doc-container-ui-controller.ts
+var import_core = require("@univerjs/core");
+var import_redi = require("@wendellhu/redi");
+var DocContainerUIController = /*#__PURE__*/ function() {
+    function DocContainerUIController(_config, _localeService, _injector) {
+        var _this = this;
+        _class_call_check(this, DocContainerUIController);
+        _define_property(this, "_docContainer", void 0);
+        // 获取SheetContainer组件
+        _define_property(this, "getComponent", function(ref) {
+            _this._docContainer = ref;
+            var container = ref.getContentRef().current;
+            if (!container) {
+                throw new Error("container is not ready");
+            }
+        });
+        /**
+   * Change language
+   * @param {String} lang new language
+   *
+   * e: {target: HTMLSelectElement } reference from  https://stackoverflow.com/a/48443771
+   *
+   */ _define_property(this, "changeLocale", function(locale) {
+            _this._localeService.setLocale(locale);
+        });
+        this._config = _config;
+        this._localeService = _localeService;
+        this._injector = _injector;
+    }
+    _create_class(DocContainerUIController, [
+        {
+            key: "getUIConfig",
+            value: function getUIConfig() {
+                var config = {
+                    injector: this._injector,
+                    config: this._config,
+                    changeLocale: this.changeLocale,
+                    getComponent: this.getComponent
+                };
+                return config;
+            }
+        },
+        {
+            key: "getContentRef",
+            value: function getContentRef() {
+                return this._docContainer.getContentRef();
+            }
+        },
+        {
+            key: "UIDidMount",
+            value: function UIDidMount(cb) {
+                if (this._docContainer) {
+                    return cb(this._docContainer);
+                }
+            }
+        },
+        {
+            key: "getDocContainer",
+            value: function getDocContainer() {
+                return this._docContainer;
+            }
+        }
+    ]);
+    return DocContainerUIController;
+}();
+DocContainerUIController = __decorateClass([
+    __decorateParam(1, (0, import_redi.Inject)(import_core.LocaleService)),
+    __decorateParam(2, (0, import_redi.Inject)(import_redi.Injector))
+], DocContainerUIController);
+// src/controllers/app-ui-controller.ts
+var AppUIController = /*#__PURE__*/ function() {
+    function AppUIController(_config, _localeService, _injector) {
+        var _this = this;
+        _class_call_check(this, AppUIController);
+        _define_property(this, "_docContainerController", void 0);
+        /**
+   * Change language
+   * @param {String} locale new language
+   *
+   * e: {target: HTMLSelectElement } reference from  https://stackoverflow.com/a/48443771
+   *
+   */ _define_property(this, "changeLocale", function(locale) {
+            _this._localeService.setLocale(locale);
+        });
+        this._localeService = _localeService;
+        this._injector = _injector;
+        this._docContainerController = this._injector.createInstance(DocContainerUIController, _config);
+    }
+    _create_class(AppUIController, [
+        {
+            key: "getDocContainerController",
+            value: function getDocContainerController() {
+                return this._docContainerController;
+            }
+        }
+    ]);
+    return AppUIController;
+}();
+AppUIController = __decorateClass([
+    __decorateParam(1, (0, import_redi2.Inject)(import_core2.LocaleService)),
+    __decorateParam(2, (0, import_redi2.Inject)(import_redi2.Injector))
+], AppUIController);
+// src/controllers/doc-ui.controller.ts
+var import_core3 = require("@univerjs/core");
+var import_ui2 = require("@univerjs/ui");
+var import_redi3 = require("@wendellhu/redi");
+// src/controllers/menu/menu.ts
+var import_docs = require("@univerjs/docs");
+var import_ui = require("@univerjs/ui");
+function BoldMenuItemFactory(accessor) {
+    return {
+        id: import_docs.SetInlineFormatBoldCommand.id,
+        type: import_ui.MenuItemType.BUTTON,
+        icon: "BoldSingle",
+        title: "Set bold",
+        tooltip: "toolbar.bold",
+        positions: [
+            import_ui.MenuPosition.TOOLBAR_START
+        ]
+    };
+}
+function ItalicMenuItemFactory(accessor) {
+    return {
+        id: import_docs.SetInlineFormatItalicCommand.id,
+        type: import_ui.MenuItemType.BUTTON,
+        icon: "ItalicSingle",
+        title: "Set italic",
+        tooltip: "toolbar.italic",
+        positions: [
+            import_ui.MenuPosition.TOOLBAR_START
+        ]
+    };
+}
+function UnderlineMenuItemFactory(accessor) {
+    return {
+        id: import_docs.SetInlineFormatUnderlineCommand.id,
+        type: import_ui.MenuItemType.BUTTON,
+        icon: "UnderlineSingle",
+        title: "Set underline",
+        tooltip: "toolbar.underline",
+        positions: [
+            import_ui.MenuPosition.TOOLBAR_START
+        ]
+    };
+}
+function StrikeThroughMenuItemFactory(accessor) {
+    return {
+        id: import_docs.SetInlineFormatStrikethroughCommand.id,
+        type: import_ui.MenuItemType.BUTTON,
+        icon: "StrikethroughSingle",
+        title: "Set strike through",
+        tooltip: "toolbar.strikethrough",
+        positions: [
+            import_ui.MenuPosition.TOOLBAR_START
+        ]
+    };
+}
+// src/controllers/doc-ui.controller.ts
+var DocUIController = /*#__PURE__*/ function(_import_core3_Disposable) {
+    _inherits(DocUIController, _import_core3_Disposable);
+    var _super = _create_super(DocUIController);
+    function DocUIController(_injector, _componentManager, _commandService, _shortcutService, _menuService, _uiController) {
+        _class_call_check(this, DocUIController);
+        var _this;
+        _this = _super.call(this);
+        _this._injector = _injector;
+        _this._componentManager = _componentManager;
+        _this._commandService = _commandService;
+        _this._shortcutService = _shortcutService;
+        _this._menuService = _menuService;
+        _this._uiController = _uiController;
+        _this._init();
+        return _this;
+    }
+    _create_class(DocUIController, [
+        {
+            key: "_init",
+            value: function _init() {
+                var _this = this;
+                [
+                    BoldMenuItemFactory,
+                    ItalicMenuItemFactory,
+                    UnderlineMenuItemFactory,
+                    StrikeThroughMenuItemFactory
+                ].forEach(function(factory) {
+                    _this.disposeWithMe(_this._menuService.addMenuItem(_this._injector.invoke(factory)));
+                });
+            }
+        }
+    ]);
+    return DocUIController;
+}(import_core3.Disposable);
+DocUIController = __decorateClass([
+    (0, import_core3.OnLifecycle)(import_core3.LifecycleStages.Rendered, DocUIController),
+    __decorateParam(0, (0, import_redi3.Inject)(import_redi3.Injector)),
+    __decorateParam(1, (0, import_redi3.Inject)(import_ui2.ComponentManager)),
+    __decorateParam(2, import_core3.ICommandService),
+    __decorateParam(3, import_ui2.IShortcutService),
+    __decorateParam(4, import_ui2.IMenuService),
+    __decorateParam(5, import_ui2.IUIController)
+], DocUIController);
+// src/locale/en-US.ts
+var en_US_default = {};
+// src/docs-ui-plugin.ts
+var DocsUIPlugin = (_class = /*#__PURE__*/ function(_superClass) {
+    _inherits(_class, _superClass);
+    var _super = _create_super(_class);
+    function _class(_config, _injector, _localeService) {
+        _class_call_check(this, _class);
+        var _this;
+        _this = _super.call(this, DOC_UI_PLUGIN_NAME);
+        _this._config = _config;
+        _this._injector = _injector;
+        _this._localeService = _localeService;
+        _this._localeService.load({
+            enUS: en_US_default
+        });
+        _this._config = import_core4.Tools.deepMerge({}, DefaultDocUiConfig, _this._config);
+        _this._initDependencies(_injector);
+        return _this;
+    }
+    _create_class(_class, [
+        {
+            key: "onRendered",
+            value: function onRendered() {
+                this._initModules();
+                this._markDocAsFocused();
+            }
+        },
+        {
+            key: "onDestroy",
+            value: function onDestroy() {}
+        },
+        {
+            key: "_initDependencies",
+            value: function _initDependencies(injector) {
+                var _this = this;
+                var dependencies = [
+                    [
+                        DocUIController
+                    ],
+                    [
+                        // controllers
+                        AppUIController,
+                        {
+                            useFactory: function() {
+                                return _this._injector.createInstance(AppUIController, _this._config);
+                            }
+                        }
+                    ]
+                ];
+                dependencies.forEach(function(d) {
+                    injector.add(d);
+                });
+            }
+        },
+        {
+            key: "_markDocAsFocused",
+            value: function _markDocAsFocused() {
+                var currentService = this._injector.get(import_core4.IUniverInstanceService);
+                var doc = currentService.getCurrentUniverDocInstance();
+                var id = doc.getUnitId();
+                if (id !== import_core4.DOCS_NORMAL_EDITOR_UNIT_ID_KEY && id !== import_core4.DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY) {
+                    currentService.focusUniverInstance(doc.getUnitId());
+                }
+            }
+        },
+        {
+            key: "_initModules",
+            value: function _initModules() {
+                this._injector.get(AppUIController);
+            }
+        }
+    ]);
+    return _class;
+}(_import_core4_Plugin = import_core4.Plugin), _define_property(_class, "type", import_core4.PluginType.Doc), _class);
+DocsUIPlugin = __decorateClass([
+    __decorateParam(1, (0, import_redi4.Inject)(import_redi4.Injector)),
+    __decorateParam(2, (0, import_redi4.Inject)(import_core4.LocaleService))
+], DocsUIPlugin);

package/lib/cjs/locale/en-US.js

@@ -0,0 +1,26 @@
+"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/locale/en-US.ts
+var en_US_exports = {};
+__export(en_US_exports, {
+  default: () => en_US_default
+});
+module.exports = __toCommonJS(en_US_exports);
+var en_US_default = {};

package/lib/cjs/locale/zh-CN.js

@@ -0,0 +1,26 @@
+"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/locale/zh-CN.ts
+var zh_CN_exports = {};
+__export(zh_CN_exports, {
+  default: () => zh_CN_default
+});
+module.exports = __toCommonJS(zh_CN_exports);
+var zh_CN_default = {};