@difizen/libro-app 0.2.45

package/es/app-viewer.js

@@ -0,0 +1,99 @@
+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, _dec2, _dec3, _dec4, _dec5, _class, _class2, _descriptor, _descriptor2, _descriptor3;
+function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+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(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { 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 _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
+import { ViewRender, ViewManager } from '@difizen/mana-app';
+import { BaseView, inject, LabelProvider, prop, transient, URI as VScodeURI, URIIconReference, useInject, view, ViewInstance, ViewOption, Deferred, URI, CommandRegistry } from '@difizen/mana-app';
+import { forwardRef } from 'react';
+import "./index.less";
+import { LibroAppView } from "./app-view.js";
+import { AppViewerFactory } from "./protocol.js";
+import { jsx as _jsx } from "react/jsx-runtime";
+export var AppViewerComponent = /*#__PURE__*/forwardRef(function LibroEditorComponent() {
+  var instance = useInject(ViewInstance);
+  return /*#__PURE__*/_jsx("div", {
+    className: "libro-app-viewer-container",
+    children: instance.appView && /*#__PURE__*/_jsx(ViewRender, {
+      view: instance.appView
+    })
+  });
+});
+export var LibroAppViewer = (_dec = transient(), _dec2 = view(AppViewerFactory), _dec3 = inject(CommandRegistry), _dec4 = prop(), _dec5 = prop(), _dec(_class = _dec2(_class = (_class2 = /*#__PURE__*/function (_BaseView) {
+  _inherits(LibroAppViewer, _BaseView);
+  var _super = _createSuper(LibroAppViewer);
+  function LibroAppViewer(options, labelProvider, viewManager) {
+    var _this;
+    _classCallCheck(this, LibroAppViewer);
+    _this = _super.call(this);
+    _initializerDefineProperty(_this, "commandRegistry", _descriptor, _assertThisInitialized(_this));
+    _this.view = AppViewerComponent;
+    _initializerDefineProperty(_this, "appView", _descriptor2, _assertThisInitialized(_this));
+    _initializerDefineProperty(_this, "filePath", _descriptor3, _assertThisInitialized(_this));
+    _this.defer = new Deferred();
+    _this.filePath = options.path;
+    _this.title.caption = options.path;
+    var uri = new URI(options.path);
+    viewManager.getOrCreateView(LibroAppView, options).then(function (appView) {
+      _this.appView = appView;
+      return;
+    }).catch(function () {
+      //
+    });
+    var uriRef = URIIconReference.create('file', new VScodeURI(options.path));
+    var iconClass = labelProvider.getIcon(uriRef);
+    _this.title.icon = /*#__PURE__*/_jsx("div", {
+      className: iconClass
+    });
+    _this.title.label = uri.displayName;
+    return _this;
+  }
+  LibroAppViewer = inject(ViewManager)(LibroAppViewer, undefined, 2) || LibroAppViewer;
+  LibroAppViewer = inject(LabelProvider)(LibroAppViewer, undefined, 1) || LibroAppViewer;
+  LibroAppViewer = inject(ViewOption)(LibroAppViewer, undefined, 0) || LibroAppViewer;
+  _createClass(LibroAppViewer, [{
+    key: "ready",
+    get: function get() {
+      return this.defer.promise;
+    }
+  }, {
+    key: "getResourceUri",
+    value: function getResourceUri() {
+      return new URI(this.filePath);
+    }
+  }, {
+    key: "createMoveToUri",
+    value: function createMoveToUri(resourceUri) {
+      this.filePath = resourceUri.path.toString();
+      return resourceUri;
+    }
+  }]);
+  return LibroAppViewer;
+}(BaseView), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "commandRegistry", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "appView", [_dec4], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor3 = _applyDecoratedDescriptor(_class2.prototype, "filePath", [_dec5], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class2)) || _class) || _class);

package/es/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module.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,cAAc,aAAa,CAAC"}

package/es/index.js

@@ -0,0 +1 @@
+export * from "./module.js";

package/es/index.less

@@ -0,0 +1,147 @@
+.libro-app-container {
+  background: var(--mana-libro-background);
+  height: 100%;
+
+  .libro-cell-collapsed-expander {
+    padding-left: 0;
+  }
+
+  .libro-app-container-header {
+    padding: 12px 24px;
+    border-bottom: 1px solid var(--mana-libro-code-border-color);
+  }
+
+  .libro-app-cell-container {
+    position: relative;
+  }
+
+  .libro-app-container-content {
+    height: calc(100% - 56px);
+
+    .libro-view-top {
+      display: none;
+    }
+  }
+
+  .libro-app-cell-list {
+    padding: 0 48px 12px;
+    height: 100%;
+    overflow-y: auto;
+  }
+
+  .libro-markdown-collapser {
+    position: absolute;
+    top: 4px;
+    left: -24px;
+    z-index: 90;
+    min-width: 24px;
+    white-space: pre-wrap;
+    text-align: center;
+    cursor: pointer;
+  }
+
+  .libro-markdown-warpper-container {
+    .libro-markdown-preview {
+      min-height: 50px;
+      padding: 0 4px;
+      overflow: hidden;
+
+      img {
+        max-width: 100%;
+        max-height: 100%;
+      }
+
+      a {
+        text-decoration: none;
+      }
+
+      a:hover {
+        text-decoration: underline;
+      }
+
+      a:focus,
+      input:focus,
+      select:focus,
+      textarea:focus {
+        outline: 1px solid -webkit-focus-ring-color;
+        outline-offset: -1px;
+      }
+
+      hr {
+        height: 2px;
+        border: 0;
+        border-bottom: 2px solid;
+      }
+
+      div {
+        width: 100%;
+        min-height: 20px;
+      }
+
+      /* Adjust margin of first item in markdown cell */
+      *:first-child {
+        margin-top: 0;
+      }
+
+      /* h1 tags don't need top margin */
+      h1:first-child {
+        margin-top: 0;
+      }
+
+      /* Removes bottom margin when only one item exists in markdown cell */
+      #preview > *:only-child,
+      #preview > *:last-child {
+        margin-bottom: 0;
+        padding-bottom: 0;
+      }
+
+      table {
+        border-collapse: collapse;
+        border-spacing: 0;
+      }
+
+      table th,
+      table td {
+        border: 1px solid;
+      }
+
+      table > thead > tr > th {
+        text-align: left;
+        border-bottom: 1px solid;
+      }
+
+      table > thead > tr > th,
+      table > thead > tr > td,
+      table > tbody > tr > th,
+      table > tbody > tr > td {
+        padding: 5px 10px;
+      }
+
+      table > tbody > tr + tr > td {
+        border-top: 1px solid;
+      }
+
+      blockquote {
+        margin: 0 7px 0 5px;
+        padding: 0 16px 0 10px;
+        border-left-width: 5px;
+        border-left-style: solid;
+      }
+
+      code {
+        font-size: 1em;
+      }
+
+      pre code {
+        color: var(--mana-libro-text-default-color);
+        font-family: 12px;
+        line-height: 1.357em;
+        white-space: pre-wrap;
+      }
+    }
+  }
+}
+
+.libro-app-viewer-container {
+  height: 100%;
+}

package/es/module.d.ts

@@ -0,0 +1,3 @@
+import { ManaModule } from '@difizen/mana-app';
+export declare const LibroAppModule: ManaModule;
+//# sourceMappingURL=module.d.ts.map

package/es/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAO/C,eAAO,MAAM,cAAc,YAK1B,CAAC"}

package/es/module.js

@@ -0,0 +1,6 @@
+import { ManaModule } from '@difizen/mana-app';
+import { AppFileCommandContribution } from "./app-file-command-contribution.js";
+import { LibroAppOpenHandler } from "./app-open-handler.js";
+import { LibroAppView } from "./app-view.js";
+import { LibroAppViewer } from "./app-viewer.js";
+export var LibroAppModule = ManaModule.create().register(AppFileCommandContribution, LibroAppOpenHandler, LibroAppViewer, LibroAppView);

package/es/protocol.d.ts

@@ -0,0 +1,2 @@
+export declare const AppViewerFactory = "libro-app-viewer";
+//# sourceMappingURL=protocol.d.ts.map

package/es/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,qBAAqB,CAAC"}

package/es/protocol.js

@@ -0,0 +1 @@
+export var AppViewerFactory = 'libro-app-viewer';

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@difizen/libro-app",
+  "version": "0.2.45",
+  "description": "",
+  "keywords": [
+    "libro",
+    "app"
+  ],
+  "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/libro-jupyter": "^0.2.45",
+    "@ant-design/icons": "^5.4.0",
+    "@difizen/mana-app": "latest",
+    "@difizen/mana-l10n": "latest"
+  },
+  "peerDependencies": {
+    "antd": "^5.8.6",
+    "react": ">=16"
+  },
+  "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",
+    "typecheck:tsc": "tsc --noEmit"
+  }
+}

package/src/app-file-command-contribution.tsx

@@ -0,0 +1,75 @@
+import { FileTreeContextMenuGroups, JupyterFileService } from '@difizen/libro-jupyter';
+import type { CommandRegistry, MenuRegistry, ViewManager } from '@difizen/mana-app';
+import {
+  ConfigurationService,
+  CommandContribution,
+  FileStatNode,
+  inject,
+  MenuContribution,
+  ModalService,
+  OpenerService,
+  singleton,
+} from '@difizen/mana-app';
+import { l10n } from '@difizen/mana-l10n';
+import { message } from 'antd';
+
+export const AppFileCommands = {
+  OPEN_FILE_BY_LIBRO_APP: {
+    id: 'fileTree.command.openfilebyapp',
+    label: '以报告的形式打开',
+  },
+};
+
+@singleton({
+  contrib: [CommandContribution, MenuContribution],
+})
+export class AppFileCommandContribution
+  implements CommandContribution, MenuContribution
+{
+  protected viewManager: ViewManager;
+  @inject(JupyterFileService) fileService: JupyterFileService;
+  @inject(ModalService) modalService: ModalService;
+  @inject(OpenerService) protected openService: OpenerService;
+  @inject(ConfigurationService) configurationService: ConfigurationService;
+
+  registerMenus(menu: MenuRegistry) {
+    menu.registerMenuAction(FileTreeContextMenuGroups['new'], {
+      id: AppFileCommands.OPEN_FILE_BY_LIBRO_APP.id,
+      command: AppFileCommands.OPEN_FILE_BY_LIBRO_APP.id,
+      label: () => <div>{l10n.t(AppFileCommands.OPEN_FILE_BY_LIBRO_APP.label)}</div>,
+      order: 'e',
+    });
+  }
+  registerCommands(command: CommandRegistry): void {
+    command.registerCommand(AppFileCommands.OPEN_FILE_BY_LIBRO_APP, {
+      execute: (node) => {
+        try {
+          if (node.fileStat.isFile) {
+            this.openService
+              .getOpener(node.uri, {
+                isApp: true,
+              })
+              .then((opener) => {
+                if (opener) {
+                  opener.open(node.uri, {
+                    viewOptions: {
+                      name: node.fileStat.name,
+                    },
+                  });
+                }
+                return;
+              })
+              .catch(() => {
+                throw Error();
+              });
+          }
+        } catch {
+          message.error(l10n.t('文件打开失败'));
+        }
+      },
+      isVisible: (node) => {
+        return FileStatNode.is(node) && node.fileStat.isFile;
+      },
+    });
+  }
+}

package/src/app-open-handler.ts

@@ -0,0 +1,46 @@
+import { LibroJupyterConfiguration } from '@difizen/libro-jupyter';
+import type { URI, ViewOpenHandlerOptions } from '@difizen/mana-app';
+import { ConfigurationService, inject } from '@difizen/mana-app';
+import {
+  NavigatableViewOpenHandler,
+  OpenHandler,
+  singleton,
+  Priority,
+} from '@difizen/mana-app';
+
+import type { LibroAppViewer } from './app-viewer.js';
+import { AppViewerFactory } from './protocol.js';
+
+interface AppOpenHandlerOptions extends ViewOpenHandlerOptions {
+  isApp?: boolean;
+}
+@singleton({ contrib: OpenHandler })
+export class LibroAppOpenHandler extends NavigatableViewOpenHandler<LibroAppViewer> {
+  @inject(ConfigurationService) protected configurationService: ConfigurationService;
+
+  id = AppViewerFactory;
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  canHandle(uri: URI, _options?: AppOpenHandlerOptions) {
+    if (uri.scheme === 'file' && uri.path.ext === '.ipynb' && _options?.isApp) {
+      return Priority.PRIOR + 2;
+    }
+    return Priority.IDLE;
+  }
+
+  override async open(uri: URI, options: AppOpenHandlerOptions = {}) {
+    const { viewOptions, ...extra } = options;
+    const slot = await this.configurationService.get(
+      LibroJupyterConfiguration['OpenSlot'],
+    );
+    return super.open(uri, {
+      slot,
+      viewOptions: {
+        path: uri.path.toString(),
+        ...viewOptions,
+      },
+      reveal: true,
+      ...extra,
+    });
+  }
+}

package/src/app-view.tsx

@@ -0,0 +1,142 @@
+import type { LibroView } from '@difizen/libro-jupyter';
+import {
+  ExecutableCellView,
+  LibroService,
+  CellCollapsible,
+  ArrowDown,
+  ArrowRight,
+  PlusOutlined,
+} from '@difizen/libro-jupyter';
+import {
+  BaseView,
+  inject,
+  prop,
+  transient,
+  useInject,
+  view,
+  ViewInstance,
+  ViewOption,
+  ViewRender,
+} from '@difizen/mana-app';
+import { l10n } from '@difizen/mana-l10n';
+import type { RadioChangeEvent } from 'antd';
+import { Radio, Button } from 'antd';
+import type { ReactElement } from 'react';
+import { forwardRef } from 'react';
+import './index.less';
+
+export const AppViewComponent = forwardRef(function LibroAppComponent() {
+  const instance = useInject<LibroAppView>(ViewInstance);
+
+  if (!instance.libroView || !instance.libroView.view) {
+    return null;
+  }
+
+  const handleSizeChange = (e: RadioChangeEvent) => {
+    instance.mode = e.target.value;
+  };
+  let children: ReactElement | null = null;
+  if (instance.mode === 'notebook') {
+    children = instance.libroView ? (
+      <ViewRender view={instance.libroView}></ViewRender>
+    ) : null;
+  } else {
+    children = (
+      <div className="libro-app-cell-list">
+        {instance.libroView?.model.cells.map((cell) => {
+          if (cell.collapsedHidden) {
+            return null;
+          }
+          if (ExecutableCellView.is(cell)) {
+            return <ViewRender view={cell.outputArea} key={cell.id}></ViewRender>;
+          } else {
+            const isCollapsible = CellCollapsible.is(cell);
+            return (
+              <>
+                {instance.libroView?.collapserVisible && isCollapsible && (
+                  <div className="libro-app-cell-container">
+                    <div
+                      className="libro-markdown-collapser"
+                      onClick={() => {
+                        instance.libroView?.collapseCell(cell, !cell.headingCollapsed);
+                      }}
+                    >
+                      {cell.headingCollapsed ? <ArrowRight /> : <ArrowDown />}
+                    </div>
+                    <ViewRender view={cell}></ViewRender>
+                    {isCollapsible &&
+                      cell.headingCollapsed &&
+                      cell.collapsibleChildNumber > 0 && (
+                        <div className="libro-cell-collapsed-expander">
+                          <Button
+                            className="libro-cell-expand-button"
+                            onClick={() =>
+                              instance.libroView?.collapseCell(cell, false)
+                            }
+                            icon={<PlusOutlined className="" />}
+                            type="default"
+                          >
+                            {cell.collapsibleChildNumber} cell hidden
+                          </Button>
+                        </div>
+                      )}
+                  </div>
+                )}
+              </>
+            );
+          }
+        })}
+      </div>
+    );
+  }
+  return (
+    <div className="libro-app-container">
+      <div className="libro-app-container-header">
+        <Radio.Group value={instance.mode} onChange={handleSizeChange}>
+          <Radio.Button value="app">{l10n.t('报告预览')}</Radio.Button>
+          <Radio.Button value="notebook">notebook</Radio.Button>
+        </Radio.Group>
+      </div>
+      <div className="libro-app-container-content">{children}</div>
+    </div>
+  );
+});
+
+@transient()
+@view('libro-app')
+export class LibroAppView extends BaseView {
+  @inject(LibroService) protected libroService: LibroService;
+  override view = AppViewComponent;
+
+  @prop() libroView?: LibroView;
+  path: string;
+
+  @prop()
+  mode = 'app';
+
+  constructor(@inject(ViewOption) options: { path: string }) {
+    super();
+    this.path = options.path;
+  }
+
+  override onViewMount(): void {
+    this.getOrCreateLibroView();
+  }
+
+  protected async getOrCreateLibroView() {
+    const libroView = await this.libroService.getOrCreateView({
+      id: this.path,
+      resource: this.path,
+    });
+    if (!libroView) {
+      return;
+    }
+    libroView.model.cellsEditable = false;
+    libroView.model.runnable = false;
+    libroView.model.inputEditable = false;
+    libroView.model.outputEditable = false;
+    libroView.model.savable = false;
+    this.libroView = libroView;
+    await this.libroView.initialized;
+  }
+}