@difizen/libro-rendermime 0.0.2-alpha.0

package/es/rendermime-registry.js

@@ -0,0 +1,392 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _dec, _dec2, _class, _class2, _descriptor;
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+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 _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 _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(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); }
+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 { defaultSanitizer } from '@difizen/libro-common';
+import { MarkdownParser } from '@difizen/libro-markdown';
+import { contrib, inject, singleton, Priority } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-app';
+import { RenderMimeContribution, IRenderMimeRegistryOptions } from "./rendermime-protocol.js";
+import { sortedTypes } from "./rendermime-utils.js";
+
+/**
+ * An object which manages mime renderer factories.
+ *
+ * This object is used to render mime models using registered mime
+ * renderers, selecting the preferred mime renderer to render the
+ * model into a widget.
+ *
+ * #### Notes
+ * This class is not intended to be subclassed.
+ */
+export var RenderMimeRegistry = (_dec = singleton(), _dec2 = contrib(RenderMimeContribution), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  /**
+   * Construct a new rendermime.
+   *
+   * @param options - The options for initializing the instance.
+   */
+  function RenderMimeRegistry(options, markdownParser) {
+    var _options$resolver, _options$linkHandler, _options$markdownPars, _options$sanitizer;
+    _classCallCheck(this, RenderMimeRegistry);
+    this.renderMimeEmitter = new Emitter();
+    _initializerDefineProperty(this, "renderMimeProvider", _descriptor, this);
+    /**
+     * The sanitizer used by the rendermime instance.
+     */
+    this.sanitizer = defaultSanitizer;
+    this._id = 0;
+    this._ranks = {};
+    this._types = null;
+    this._factories = {};
+    // Parse the options.
+    // this.translator = options.translator ?? nullTranslator;
+    this.resolver = (_options$resolver = options.resolver) !== null && _options$resolver !== void 0 ? _options$resolver : null;
+    this.linkHandler = (_options$linkHandler = options.linkHandler) !== null && _options$linkHandler !== void 0 ? _options$linkHandler : null;
+    this.markdownParser = (_options$markdownPars = options.markdownParser) !== null && _options$markdownPars !== void 0 ? _options$markdownPars : markdownParser;
+    this.sanitizer = (_options$sanitizer = options.sanitizer) !== null && _options$sanitizer !== void 0 ? _options$sanitizer : defaultSanitizer;
+
+    // Add the initial factories.
+    if (options.initialFactories) {
+      var _iterator = _createForOfIteratorHelper(options.initialFactories),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var factory = _step.value;
+          this.addFactory(factory);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+  }
+  RenderMimeRegistry = inject(MarkdownParser)(RenderMimeRegistry, undefined, 1) || RenderMimeRegistry;
+  RenderMimeRegistry = inject(IRenderMimeRegistryOptions)(RenderMimeRegistry, undefined, 0) || RenderMimeRegistry;
+  _createClass(RenderMimeRegistry, [{
+    key: "onMimeRender",
+    get: function get() {
+      return this.renderMimeEmitter.event;
+    }
+  }, {
+    key: "mimeTypes",
+    get:
+    /**
+     * The object used to resolve relative urls for the rendermime instance.
+     */
+
+    /**
+     * The object used to handle path opening links.
+     */
+
+    /**
+     * The Markdown parser for the rendermime.
+     */
+
+    // /**
+    //  * The application language translator.
+    //  */
+    // readonly translator: ITranslator;
+    /**
+     * The ordered list of mimeTypes.
+     */
+    function get() {
+      return this._types || (this._types = sortedTypes(this._ranks));
+    }
+  }, {
+    key: "getSortedRenderMimes",
+    value: function getSortedRenderMimes(model) {
+      var prioritized = Priority.sortSync(this.renderMimeProvider.getContributions(), function (contribution) {
+        return contribution.canHandle(model);
+      });
+      var sortedRenderMimes = prioritized.map(function (c) {
+        return c.value;
+      });
+      return sortedRenderMimes;
+    }
+  }, {
+    key: "defaultPreferredMimeType",
+    value: function defaultPreferredMimeType(model
+    // safe: 'ensure' | 'prefer' | 'any' = 'ensure',
+    ) {
+      var _iterator2 = _createForOfIteratorHelper(this.mimeTypes),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var mt = _step2.value;
+          if (mt in model.data) {
+            return mt;
+          }
+        }
+
+        // Otherwise, no matching mime type exists.
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      return undefined;
+    }
+
+    /**
+     * Find the preferred mime type for a mime bundle.
+     *
+     * @param bundle - The bundle of mime data.
+     *
+     * @param safe - How to consider safe/unsafe factories. If 'ensure',
+     *   it will only consider safe factories. If 'any', any factory will be
+     *   considered. If 'prefer', unsafe factories will be considered, but
+     *   only after the safe options have been exhausted.
+     *
+     * @returns The preferred mime type from the available factories,
+     *   or `undefined` if the mime type cannot be rendered.
+     */
+  }, {
+    key: "preferredMimeType",
+    value: function preferredMimeType(model
+    // safe: 'ensure' | 'prefer' | 'any' = 'ensure',
+    ) {
+      // // Try to find a safe factory first, if preferred.
+      // if (safe === 'ensure' || safe === 'prefer') {
+      //   for (const mt of this.mimeTypes) {
+      //     if (mt in bundle && this._factories[mt].safe) {
+      //       return mt;
+      //     }
+      //   }
+      // }
+
+      // if (safe !== 'ensure') {
+      //   // Otherwise, search for the best factory among all factories.
+      //   for (const mt of this.mimeTypes) {
+      //     if (mt in bundle) {
+      //       return mt;
+      //     }
+      //   }
+      // }
+      var sortedRenderMimes = this.getSortedRenderMimes(model);
+      var _iterator3 = _createForOfIteratorHelper(sortedRenderMimes),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var renderMime = _step3.value;
+          var _iterator5 = _createForOfIteratorHelper(renderMime.mimeTypes),
+            _step5;
+          try {
+            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+              var mt = _step5.value;
+              if (mt in model.data) {
+                return mt;
+              }
+            }
+          } catch (err) {
+            _iterator5.e(err);
+          } finally {
+            _iterator5.f();
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      var _iterator4 = _createForOfIteratorHelper(this.mimeTypes),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var _mt = _step4.value;
+          if (_mt in model.data) {
+            return _mt;
+          }
+        }
+
+        // Otherwise, no matching mime type exists.
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+      return undefined;
+    }
+
+    /**
+     * Create a renderer for a mime type.
+     *
+     * @param mimeType - The mime type of interest.
+     *
+     * @returns A new renderer for the given mime type.
+     *
+     * @throws An error if no factory exists for the mime type.
+     */
+  }, {
+    key: "createRenderer",
+    value: function createRenderer(mimeType, model // model: BaseOutputModel,
+    // host: HTMLElement,
+    ) {
+      var renderMimes = this.getSortedRenderMimes(model);
+      var _iterator6 = _createForOfIteratorHelper(renderMimes),
+        _step6;
+      try {
+        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+          var renderMime = _step6.value;
+          var _iterator7 = _createForOfIteratorHelper(renderMime.mimeTypes),
+            _step7;
+          try {
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              var mt = _step7.value;
+              if (mimeType === mt) {
+                var _OutputRender = renderMime.render;
+                this.renderMimeEmitter.fire({
+                  renderType: renderMime.renderType,
+                  mimeType: mimeType
+                });
+                return _OutputRender;
+              }
+            }
+          } catch (err) {
+            _iterator7.e(err);
+          } finally {
+            _iterator7.f();
+          }
+        }
+
+        // Throw an error if no factory exists for the mime type.
+      } catch (err) {
+        _iterator6.e(err);
+      } finally {
+        _iterator6.f();
+      }
+      if (!(mimeType in this._factories)) {
+        throw new Error("No factory for mime type: '".concat(mimeType, "'"));
+      }
+      var OutputRender = this._factories[mimeType].render;
+      this.renderMimeEmitter.fire({
+        renderType: this._factories[mimeType].renderType,
+        mimeType: mimeType
+      });
+      // Invoke the best factory for the given mime type.
+      return OutputRender;
+    }
+
+    /**
+     * Get the renderer factory registered for a mime type.
+     *
+     * @param mimeType - The mime type of interest.
+     *
+     * @returns The factory for the mime type, or `undefined`.
+     */
+  }, {
+    key: "getFactory",
+    value: function getFactory(mimeType) {
+      return this._factories[mimeType];
+    }
+
+    /**
+     * Add a renderer factory to the rendermime.
+     *
+     * @param factory - The renderer factory of interest.
+     *
+     * @param _rank - The rank of the renderer. A lower rank indicates
+     *   a higher priority for rendering. If not given, the rank will
+     *   defer to the `defaultRank` of the factory.  If no `defaultRank`
+     *   is given, it will default to 100.
+     *
+     * #### Notes
+     * The renderer will replace an existing renderer for the given
+     * mimeType.
+     */
+  }, {
+    key: "addFactory",
+    value: function addFactory(factory, _rank) {
+      var rank = _rank;
+      if (rank === undefined) {
+        rank = factory.defaultRank;
+        if (rank === undefined) {
+          rank = 100;
+        }
+      }
+      var _iterator8 = _createForOfIteratorHelper(factory.mimeTypes),
+        _step8;
+      try {
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var mt = _step8.value;
+          this._factories[mt] = factory;
+          this._ranks[mt] = {
+            rank: rank,
+            id: this._id++
+          };
+        }
+      } catch (err) {
+        _iterator8.e(err);
+      } finally {
+        _iterator8.f();
+      }
+      this._types = null;
+    }
+
+    /**
+     * Remove a mime type.
+     *
+     * @param mimeType - The mime type of interest.
+     */
+  }, {
+    key: "removeMimeType",
+    value: function removeMimeType(mimeType) {
+      delete this._factories[mimeType];
+      delete this._ranks[mimeType];
+      this._types = null;
+    }
+
+    /**
+     * Get the rank for a given mime type.
+     *
+     * @param mimeType - The mime type of interest.
+     *
+     * @returns The rank of the mime type or undefined.
+     */
+  }, {
+    key: "getRank",
+    value: function getRank(mimeType) {
+      var rank = this._ranks[mimeType];
+      return rank && rank.rank;
+    }
+
+    /**
+     * Set the rank of a given mime type.
+     *
+     * @param mimeType - The mime type of interest.
+     *
+     * @param rank - The new rank to assign.
+     *
+     * #### Notes
+     * This is a no-op if the mime type is not registered.
+     */
+  }, {
+    key: "setRank",
+    value: function setRank(mimeType, rank) {
+      if (!this._ranks[mimeType]) {
+        return;
+      }
+      var id = this._id++;
+      this._ranks[mimeType] = {
+        rank: rank,
+        id: id
+      };
+      this._types = null;
+    }
+  }]);
+  return RenderMimeRegistry;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "renderMimeProvider", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+})), _class2)) || _class);

package/es/rendermime-utils.d.ts

@@ -0,0 +1,87 @@
+import type { IOutput, ISanitizer, PartialJSONObject, PartialJSONValue, ReadonlyPartialJSONObject } from '@difizen/libro-common';
+import type { ILinkHandler, IResolver, RankMap } from './rendermime-protocol.js';
+/**
+ * Get the data from a notebook output.
+ */
+export declare function getData(output: IOutput): PartialJSONObject;
+/**
+ * Extract a value from a JSONObject.
+ */
+export declare function extract(value: ReadonlyPartialJSONObject, key: string): PartialJSONValue | undefined;
+/**
+ * Transform ANSI color escape codes into HTML <span> tags with CSS
+ * classes such as "ansi-green-intense-fg".
+ * The actual colors used are set in the CSS file.
+ * This also removes non-color escape sequences.
+ * This is supposed to have the same behavior as nbconvert.filters.ansi2html()
+ */
+export declare function ansiSpan(str: string): string;
+/**
+ * Replace URLs with links.
+ *
+ * @param content - The text content of a node.
+ *
+ * @returns A list of text nodes and anchor elements.
+ */
+export declare function autolink(content: string): (HTMLAnchorElement | Text)[];
+export interface IRenderOptions {
+    /**
+     * The host node for the text content.
+     */
+    host: HTMLElement;
+    /**
+     * The html sanitizer for untrusted source.
+     */
+    sanitizer: ISanitizer;
+    /**
+     * The source text to render.
+     */
+    source: string;
+}
+/**
+ * Split a shallow node (node without nested nodes inside) at a given text content position.
+ *
+ * @param node the shallow node to be split
+ * @param at the position in textContent at which the split should occur
+ */
+export declare function splitShallowNode<T extends Node>(node: T, at: number): {
+    pre: T;
+    post: T;
+};
+export declare function sortedTypes(map: RankMap): string[];
+/**
+ * Eval the script tags contained in a host populated by `innerHTML`.
+ *
+ * When script tags are created via `innerHTML`, the browser does not
+ * evaluate them when they are added to the page. This function works
+ * around that by creating new equivalent script nodes manually, and
+ * replacing the originals.
+ */
+export declare function evalInnerHTMLScriptTags(host: HTMLElement): void;
+/**
+ * Handle the default behavior of nodes.
+ */
+export declare function handleDefaults(node: HTMLElement, resolver?: IResolver | null): void;
+/**
+ * Resolve the relative urls in element `src` and `href` attributes.
+ *
+ * @param node - The head html element.
+ *
+ * @param resolver - A url resolver.
+ *
+ * @param linkHandler - An optional link handler for nodes.
+ *
+ * @returns a promise fulfilled when the relative urls have been resolved.
+ */
+export declare function handleUrls(node: HTMLElement, resolver: IResolver, linkHandler: ILinkHandler | null): Promise<void>;
+/**
+ * Create a normalized id for a header element.
+ *
+ * @param header Header element
+ * @returns Normalized id
+ */
+export declare function createHeaderId(header: Element): string;
+/**
+ * Apply ids to headers.
+ */
+//# sourceMappingURL=rendermime-utils.d.ts.map

package/es/rendermime-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendermime-utils.d.ts","sourceRoot":"","sources":["../src/rendermime-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,OAAO,EACP,UAAU,EACV,iBAAiB,EACjB,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,uBAAuB,CAAC;AAa/B,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEjF;;GAEG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,iBAAiB,CAiB1D;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,yBAAyB,EAChC,GAAG,EAAE,MAAM,GACV,gBAAgB,GAAG,SAAS,CAM9B;AA8ID;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAqI5C;AACD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,CAAC,iBAAiB,GAAG,IAAI,CAAC,EAAE,CAuCtE;AACD,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;IAElB;;OAEG;IACH,SAAS,EAAE,UAAU,CAAC;IAEtB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB;AACD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,IAAI,EAC7C,IAAI,EAAE,CAAC,EACP,EAAE,EAAE,MAAM,GACT;IAAE,GAAG,EAAE,CAAC,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,CASrB;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,EAAE,CASlD;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CA2B/D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,SAAS,GAAG,IAAI,GAAG,IAAI,CA8BnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,SAAS,EACnB,WAAW,EAAE,YAAY,GAAG,IAAI,GAC/B,OAAO,CAAC,IAAI,CAAC,CAwBf;AAoFD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAEtD;AAED;;GAEG"}