@heartlandone/vega 2.34.1 → 2.35.0-RTE-preview

package/dist/cjs/global-slimmer-registry-b3bce7e0.js

@@ -0,0 +1,297 @@
+'use strict';
+
+/**
+ *  LogUtility is a wrapper class for console.log/warn/error with vega branding prefix
+ */
+class LogUtility$1 {
+  /**
+   * `setVegaLogLevel` sets the log level for the Vega logger
+   *
+   * @param {LogLevelType} level - The log level to set.
+   */
+  static setVegaLogLevel(level) {
+    this.logLevel = level;
+  }
+  /**
+   * Prints a log message to the console
+   *
+   * @param {unknown[]} message - The message to log.
+   */
+  static log(...message) {
+    if (this.shouldLog('log')) {
+      console.log(`%c${this.LOG_PREFIX_STR}`, this.LOG_PREFIX_STYLE, ...message);
+    }
+  }
+  /**
+   * Prints a warning message to the console
+   *
+   * @param {unknown[]} message - The message to log.
+   */
+  static warn(...message) {
+    if (this.shouldLog('warn')) {
+      console.warn(`%c${this.LOG_PREFIX_STR}`, this.LOG_PREFIX_STYLE, ...message);
+    }
+  }
+  /**
+   * Prints an error message to the console
+   *
+   * @param {unknown[]} message - The message to be logged.
+   */
+  static error(...message) {
+    if (this.shouldLog('error')) {
+      console.error(`%c${this.LOG_PREFIX_STR}`, this.LOG_PREFIX_STYLE, ...message);
+    }
+  }
+  /**
+   * If the current log level is less than or equal to the expected log level, then log
+   *
+   * @param {LogLevelType} level - LogLevelType - The log level of the message.
+   * @returns {boolean} A boolean value.
+   */
+  static shouldLog(level) {
+    const current = this.LOG_LEVELS.findIndex((item) => item === level);
+    const expect = this.LOG_LEVELS.findIndex((item) => item === this.logLevel);
+    return current <= expect;
+  }
+}
+LogUtility$1.logLevel = 'error';
+LogUtility$1.LOG_PREFIX_STR = '[Vega]';
+LogUtility$1.LOG_PREFIX_STYLE = 'font-weight: bold';
+LogUtility$1.LOG_LEVELS = ['off', 'error', 'warn', 'log'];
+/**
+ * > Sets the log level for the Vega library
+ *
+ * @param {LogLevelType} level - The log level to set.
+ * @returns {void} -
+ */
+function setVegaLogLevel(level) {
+  LogUtility$1.setVegaLogLevel(level);
+}
+
+/**
+ *  LogUtility is a wrapper class for console.log/warn/error with vega branding prefix
+ */
+class LogUtility {
+  /**
+   * Prints a log message to the console
+   *
+   * @param {unknown[]} message - The message to log.
+   */
+  static log(...message) {
+    console.log(`%c${this.LOG_PREFIX_STR}`, this.LOG_PREFIX_STYLE, ...message);
+  }
+  /**
+   * Prints a warning message to the console
+   *
+   * @param {unknown[]} message - The message to log.
+   */
+  static warn(...message) {
+    console.warn(`%c${this.LOG_PREFIX_STR}`, this.LOG_PREFIX_STYLE, ...message);
+  }
+  /**
+   * Prints an error message to the console
+   *
+   * @param {unknown[]} message - The message to be logged.
+   */
+  static error(...message) {
+    console.error(`%c${this.LOG_PREFIX_STR}`, this.LOG_PREFIX_STYLE, ...message);
+  }
+}
+LogUtility.LOG_PREFIX_STR = '[Vega]';
+LogUtility.LOG_PREFIX_STYLE = 'font-weight: bold';
+
+const SlimmerMappedMethod = Symbol('ProcessorInternalCallback');
+const SlimmerConsumedBy = Symbol('SlimmerConsumedBy');
+const ConsumerSlimmers = Symbol('ConsumerSlimmers');
+const CurrentlyInvokedMethodName = Symbol('CurrentlyInvokedMethodName');
+
+/**
+ * Decorator to map a slimmer field to a component field, which means:
+ * - If you get the slimmer field value, it will return the corresponding component field value.
+ * - If you set the slimmer field to some value, it will set the corresponding component field to the same value (if not readonly).
+ *
+ * We will use the component field name as the default value for the slimmer field name.
+ *
+ * @param {MapToComponentFieldOptions} options The options for the decorator
+ * @returns {Function} The decorator function
+ */
+function MapToComponentField(options) {
+  return function (slimmerPrototype, propertyKey) {
+    Object.defineProperty(slimmerPrototype, propertyKey, {
+      get: createSlimmerMappingFieldGetter(propertyKey, options),
+      set: createSlimmerMappingFieldSetter(propertyKey, options),
+      configurable: true,
+    });
+  };
+}
+/**
+ * Helper function to create a setter for a slimmer field that maps to the injecting component field.
+ * We will use the component field name as the default value for the slimmer field name.
+ *
+ * @param {string} slimmerFieldName The name of the slimmer field
+ * @param {MapToComponentFieldOptions} options The options of the slimmer field
+ * @returns {Function} A setter for the slimmer field
+ */
+function createSlimmerMappingFieldSetter(slimmerFieldName, options = {}) {
+  return function (value) {
+    var _a;
+    if (!options.writable) {
+      LogUtility.error(`${slimmerFieldName} is not writable`);
+      return;
+    }
+    const dependentComponent = this[SlimmerConsumedBy];
+    const fieldName = (_a = options.componentFieldName) !== null && _a !== void 0 ? _a : slimmerFieldName;
+    dependentComponent[fieldName] = value;
+  };
+}
+/**
+ * Helper function to create a getter for a slimmer field that maps to the injecting component field.
+ * We will use the component field name as the default value for the slimmer field name.
+ *
+ * @param {string} slimmerFieldName The name of the slimmer field
+ * @param {MapToComponentFieldOptions} options The options of the slimmer field
+ * @returns {Function} A getter for the slimmer field
+ */
+function createSlimmerMappingFieldGetter(slimmerFieldName, options = {}) {
+  return function () {
+    const { componentFieldName } = options;
+    const dependentComponent = this[SlimmerConsumedBy];
+    const fieldName = componentFieldName !== null && componentFieldName !== void 0 ? componentFieldName : slimmerFieldName;
+    return dependentComponent[fieldName];
+  };
+}
+
+/**
+ * The function `MapToComponentMethod` is a TypeScript decorator that maps a method in a class to a
+ * method in a component.
+ *
+ * @param {string} componentMethodName - The componentMethodName parameter is a string that represents
+ * the name of the method in the component that you want to map to.
+ * @returns A property decorator function is being returned.
+ */
+function MapToComponentMethod(componentMethodName) {
+  return function (processorPrototype, propertyKey) {
+    initPrototypeSlimmerMappedMethodArray(processorPrototype);
+    processorPrototype[SlimmerMappedMethod].push({
+      componentMethodName,
+      slimmerMethodName: propertyKey,
+    });
+  };
+}
+/**
+ * The function initializes a property on a class prototype called "SlimmerMappedMethod" as an array if it doesn't already exist.
+ * Use the `hasOwnProperty` method make sure the child slimmer not effect the parent slimmer
+ *
+ * @param {ClassPrototype<VegaSlimmer>} processorPrototype -  It represents the prototype of a class called `VegaSlimmer`.
+ */
+function initPrototypeSlimmerMappedMethodArray(processorPrototype) {
+  if (!Object.prototype.hasOwnProperty.call(processorPrototype, SlimmerMappedMethod)) {
+    processorPrototype[SlimmerMappedMethod] = (processorPrototype[SlimmerMappedMethod] ? [].concat(processorPrototype[SlimmerMappedMethod]) : []);
+  }
+}
+
+/**
+ * This decorator is used to re-define a field in a vega component
+ * which will be used for injecting the VegaSlimmer into the vega component.
+ *
+ * @returns {Function} The decorator function.
+ */
+function InjectVegaSlimmer() {
+  return function (componentPrototype, propertyKey) {
+    Object.defineProperty(componentPrototype, propertyKey, {
+      set: createSetterForVegaSlimmerField(propertyKey),
+      get: createGetterForVegaSlimmerField(propertyKey),
+    });
+  };
+}
+/**
+ * Creates a setter for a vega slimmer field which will be used for injecting the VegaSlimmer into the vega component.
+ *
+ * @param {string} fieldName The name of the field to inject the VegaSlimmer into.
+ * @returns {Function} A setter for the vega slimmer field.
+ */
+function createSetterForVegaSlimmerField(fieldName) {
+  return function (slimmer) {
+    if (!this[ConsumerSlimmers]) {
+      this[ConsumerSlimmers] = new Map();
+    }
+    this[ConsumerSlimmers].set(fieldName, slimmer);
+    slimmer[SlimmerConsumedBy] = this;
+    registerSlimMethodsToComponent(slimmer, this);
+  };
+}
+/**
+ * Creates a getter for a vega slimmer field which will be used for injecting the VegaSlimmer into the vega component.
+ *
+ * @param {string} fieldName The name of the field to inject the VegaSlimmer into.
+ * @returns {Function} A getter for the vega slimmer field.
+ */
+function createGetterForVegaSlimmerField(fieldName) {
+  return function () {
+    return this[ConsumerSlimmers].get(fieldName);
+  };
+}
+/**
+ * Given a VegaSlimmer and a component, register the slimmer methods to the component.
+ * This is done by appending the slimmer methods to the end of the corresponding component method.
+ *
+ * @param {VegaSlimmer} slimmer The slimmer to register the slimmer method to.
+ * @param {ComponentInterface} component The component to register the slimmer method to.
+ * @returns {void}
+ */
+function registerSlimMethodsToComponent(slimmer, component) {
+  const slimmerPrototype = slimmer.constructor.prototype;
+  if (slimmerPrototype[SlimmerMappedMethod]) {
+    for (const entry of slimmerPrototype[SlimmerMappedMethod]) {
+      component[entry.componentMethodName] = createRegisteredSlimMethod(component, slimmer, component[entry.componentMethodName], entry);
+    }
+  }
+}
+/**
+ * Append the slimmer methods to the end of the corresponding component method.
+ * Which means the slimmer method will be called when the original method is invoked in the component.
+ *
+ * @param {ComponentInterface} component The component to register the slimmer method to.
+ * @param {VegaSlimmer} slimmer The slimmer to register the slimmer method to.
+ * @param {Function} originalMethod The original method to override.
+ * @param {SlimmerMappedMethodEntry} mapEntry The map entry for the slimmer method.
+ * @returns {Function} The registered slimmer method.
+ */
+function createRegisteredSlimMethod(component, slimmer, originalMethod, mapEntry) {
+  return function (...args) {
+    const result = originalMethod === null || originalMethod === void 0 ? void 0 : originalMethod.apply(component, args);
+    if (result && typeof result.then === 'function') {
+      return result.then(() => slimmer[mapEntry.slimmerMethodName].call(slimmer, ...args));
+    }
+    else {
+      return slimmer[mapEntry.slimmerMethodName].call(slimmer, ...args);
+    }
+  };
+}
+
+/**
+ * An abstract class VegaSlimmer
+ */
+class VegaSlimmer {
+}
+
+class GlobalSlimmersRegistry {
+  static register(slimmers) {
+    this.globalSlimmers = slimmers;
+  }
+}
+GlobalSlimmersRegistry.globalSlimmers = [];
+
+exports.ConsumerSlimmers = ConsumerSlimmers;
+exports.CurrentlyInvokedMethodName = CurrentlyInvokedMethodName;
+exports.GlobalSlimmersRegistry = GlobalSlimmersRegistry;
+exports.InjectVegaSlimmer = InjectVegaSlimmer;
+exports.LogUtility = LogUtility$1;
+exports.MapToComponentField = MapToComponentField;
+exports.MapToComponentMethod = MapToComponentMethod;
+exports.SlimmerConsumedBy = SlimmerConsumedBy;
+exports.SlimmerMappedMethod = SlimmerMappedMethod;
+exports.VegaSlimmer = VegaSlimmer;
+exports.createGetterForVegaSlimmerField = createGetterForVegaSlimmerField;
+exports.createSetterForVegaSlimmerField = createSetterForVegaSlimmerField;
+exports.setVegaLogLevel = setVegaLogLevel;

package/dist/cjs/{icon-manager-36dcfb65.js → icon-manager-edc2400b.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-require('./global-slimmer-registry-dd2691b8.js');
-const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-8c6a8fb7.js');
+require('./global-slimmer-registry-b3bce7e0.js');
+const createPublicApiRuntimeMetricsSlimmer = require('./create-public-api-runtime-metrics-slimmer-54c3f73b.js');
 
 const VegaIconManagerRuntimeMetricsPayloadDefinition = [
   {

package/dist/cjs/{text-color-toolbar-button-slimmer-21a166e4.js → image-annotation-action-d3e1699c.js}

@@ -1,10 +1,12 @@
 'use strict';
 
-const globalSlimmerRegistry = require('./global-slimmer-registry-dd2691b8.js');
-const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-093462f1.js');
-const internalIconManager = require('./internal-icon-manager-2282a62f.js');
-const textNode = require('./text-node-494856f3.js');
-const node_abstract = require('./node.abstract-f8075f84.js');
+const index = require('./index-09acd3c9.js');
+const globalSlimmerRegistry = require('./global-slimmer-registry-b3bce7e0.js');
+const domNodeSubjectObserverFactory = require('./dom-node-subject-observer-factory-5f0eae19.js');
+const domNodeSubjectFactory = require('./dom-node-subject-factory-3ec114b8.js');
+const internalIconManager = require('./internal-icon-manager-5ccb9443.js');
+const listBlock = require('./list-block-91116257.js');
+const nodeAnnotation_abstract = require('./node-annotation.abstract-e5d3a859.js');
 
 var __decorate$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -17,9 +19,9 @@ class ToolbarButtonSlimmer extends globalSlimmerRegistry.VegaSlimmer {
     super();
     this.renderBtn = ({ showArrowIcon, iconColor } = {}) => {
       var _a, _b;
-      return (globalSlimmerRegistry.h("vega-tooltip", { text: this.tooltip.text, placement: ['bottom', 'top'] },
-        globalSlimmerRegistry.h("vega-rich-text-editor-toolbar-button", Object.assign({ showArrowIcon: showArrowIcon, icon: this.icon, iconColor: iconColor, ref: (ref) => {
-            domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectObserverFactory.VegaClick, () => {
+      return (index.h("vega-tooltip", { text: this.tooltip.text, placement: ['bottom', 'top'] },
+        index.h("vega-rich-text-editor-toolbar-button", Object.assign({ showArrowIcon: showArrowIcon, icon: this.icon, iconColor: iconColor, ref: (ref) => {
+            domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectFactory.VegaClick, () => {
               this.handleClick();
             });
           }, selected: this.isSelected(), disabled: (_a = this.isDisabled) === null || _a === void 0 ? void 0 : _a.call(this) }, this.preventLostFocus()), (_b = this.renderSlotContent) === null || _b === void 0 ? void 0 : _b.call(this))));
@@ -72,7 +74,7 @@ const text = {
 /**
  * Action to toggle the text color annotation visibility/state.
  */
-class TextColorAnnotationAction extends textNode.TextSplittableAction {
+class TextColorAnnotationAction extends listBlock.TextSplittableAction {
   constructor(textColor) {
     super();
     this.isFlushable = true;
@@ -84,7 +86,7 @@ class TextColorAnnotationAction extends textNode.TextSplittableAction {
    * @returns {TextColorAnnotation} the annotation
    */
   toAnnotation() {
-    return new textNode.TextColorAnnotation(this.textColor);
+    return new listBlock.TextColorAnnotation(this.textColor);
   }
 }
 
@@ -101,16 +103,16 @@ class TextColorToolbarButtonSlimmer extends ToolbarButtonSlimmer {
       tooltip: { text: 'Text Color' },
     });
     this.popoverShow = false;
-    node_abstract.VegaDarkModeStyleController.registerCustomDarkModeColor(TextColorToolbarButtonSlimmer.formatDarkModeColor());
+    nodeAnnotation_abstract.VegaDarkModeStyleController.registerCustomDarkModeColor(TextColorToolbarButtonSlimmer.formatDarkModeColor());
   }
   static formatDarkModeColor() {
-    return textNode.RTE_TEXT_COLORS.reduce((prev, current) => {
+    return listBlock.RTE_TEXT_COLORS.reduce((prev, current) => {
       current.dark && (prev[`rich-text-editor-${current.key}`] = current.dark);
       return prev;
     }, {});
   }
   renderSlotContent() {
-    return (globalSlimmerRegistry.h("div", { class: "toolbar-btn-color-preview-box", style: {
+    return (index.h("div", { class: "toolbar-btn-color-preview-box", style: {
         backgroundColor: this.getCurrentColor(),
       } }));
   }
@@ -121,19 +123,19 @@ class TextColorToolbarButtonSlimmer extends ToolbarButtonSlimmer {
     this.popoverShow = false;
   }
   renderBtnWrapper(renderBtn) {
-    return (globalSlimmerRegistry.h("vega-popover", { placement: "bottom", alignment: "center", ref: (ref) => {
+    return (index.h("vega-popover", { placement: "bottom", alignment: "center", ref: (ref) => {
         this.popoverRef = ref;
-        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectObserverFactory.VegaPopoverShow, this.handlePopoverShowChange.bind(this));
-        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectObserverFactory.VegaPopoverHide, this.handlePopoverHideChange.bind(this));
+        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectFactory.VegaPopoverShow, this.handlePopoverShowChange.bind(this));
+        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectFactory.VegaPopoverHide, this.handlePopoverHideChange.bind(this));
       } },
-      globalSlimmerRegistry.h("div", { slot: "popover-content" }, renderBtn({
+      index.h("div", { slot: "popover-content" }, renderBtn({
         showArrowIcon: false,
       })),
-      globalSlimmerRegistry.h("div", Object.assign({ slot: "popover", style: { userSelect: 'none' } }, super.preventLostFocus()), this.renderPopoverContent())));
+      index.h("div", Object.assign({ slot: "popover", style: { userSelect: 'none' } }, super.preventLostFocus()), this.renderPopoverContent())));
   }
   renderPopoverContent() {
-    return (globalSlimmerRegistry.h("vega-color-picker", { isInline: true, colors: textNode.RTE_TEXT_COLORS.map((item) => item[!this.isInDarkMode ? 'light' : 'dark']), ref: (ref) => {
-        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectObserverFactory.VegaChange, this.handleChange.bind(this));
+    return (index.h("vega-color-picker", { isInline: true, colors: listBlock.RTE_TEXT_COLORS.map((item) => item[!this.isInDarkMode ? 'light' : 'dark']), ref: (ref) => {
+        domNodeSubjectObserverFactory.DomNodeSubjectObserverFactory.addUniqueObserverToNode(ref, domNodeSubjectFactory.VegaChange, this.handleChange.bind(this));
       }, value: this.getCurrentColor() }));
   }
   async handleChange(e) {
@@ -143,16 +145,16 @@ class TextColorToolbarButtonSlimmer extends ToolbarButtonSlimmer {
       }
       this.selectionController
         .getSelectedNodes()
-        .filter((node) => node instanceof textNode.RTETextNode)
+        .filter((node) => node instanceof listBlock.RTETextNode)
         .forEach((node) => node.apply(new TextColorAnnotationAction(this.matchColor(e.detail).key)));
     }
     void this.popoverRef.hide();
   }
   matchColor(value) {
-    return textNode.RTE_TEXT_COLORS.find((item) => item[this.isInDarkMode ? 'dark' : 'light'] === value);
+    return listBlock.RTE_TEXT_COLORS.find((item) => item[this.isInDarkMode ? 'dark' : 'light'] === value);
   }
   getCurrentColor() {
-    let selectedItem = textNode.RTE_TEXT_COLORS[0];
+    let selectedItem = listBlock.RTE_TEXT_COLORS[0];
     const selectedNodes = this.selectionController.getSelectedNodes();
     if (selectedNodes.length > 1) {
       if (this.isSelectedSameColor(selectedNodes)) {
@@ -176,15 +178,15 @@ class TextColorToolbarButtonSlimmer extends ToolbarButtonSlimmer {
   getTextColor(selectedNodes) {
     var _a;
     return (((_a = selectedNodes.getAnnotationByType('TEXT_COLOR')) === null || _a === void 0 ? void 0 : _a.textColor) ||
-      textNode.RTE_TEXT_COLORS[0]);
+      listBlock.RTE_TEXT_COLORS[0]);
   }
   isDisabled() {
     const selectedNodes = this.selectionController.getSelectedNodes();
     return selectedNodes.some((node) => {
       var _a;
-      return ((_a = node.getAnnotationByType(node_abstract.NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
-        node.getAnnotationByType(node_abstract.NodeAnnotationTypeEnum.LINK) ||
-        node.getAnnotationByType(node_abstract.NodeAnnotationTypeEnum.IMAGE);
+      return ((_a = node.getAnnotationByType(nodeAnnotation_abstract.NodeAnnotationTypeEnum.CODE)) === null || _a === void 0 ? void 0 : _a.code) ||
+        node.getAnnotationByType(nodeAnnotation_abstract.NodeAnnotationTypeEnum.LINK) ||
+        node.getAnnotationByType(nodeAnnotation_abstract.NodeAnnotationTypeEnum.IMAGE);
     });
   }
 }
@@ -206,5 +208,54 @@ __decorate([
   globalSlimmerRegistry.MapToComponentField()
 ], TextColorToolbarButtonSlimmer.prototype, "focusController", void 0);
 
+/**
+ * This class is responsible for keeping track of the DOM elements.
+ */
+class TextNodeRenderingRegistry {
+  constructor() {
+    this.textNodeElements = new Map();
+  }
+  /**
+   * Registers a DOM element and the color annotation of the DOM element.
+   *
+   * @param {HTMLElement} dom The DOM element to register.
+   * @param {TextColorAnnotation} textColorAnnotation The text color annotation of text node to register.
+   */
+  register(dom, textColorAnnotation) {
+    this.textNodeElements.set(dom, textColorAnnotation);
+  }
+  /**
+   * Retrieves the text node elements.
+   *
+   * @returns {HTMLElement[]} The text node elements, or empty array.
+   */
+  getTextNodeElements() {
+    return this.textNodeElements;
+  }
+}
+const TextNodeRenderingRegistry$1 = new TextNodeRenderingRegistry();
+
+/**
+ * Action to add an image annotation to the editor
+ */
+class ImageAnnotationAction extends listBlock.AnnotationAction {
+  constructor(size, alt) {
+    super();
+    this.isFlushable = true;
+    this.size = size;
+    this.alt = alt;
+  }
+  /**
+   * Converts the action to an annotation
+   *
+   * @returns {ImageAnnotation} The annotation
+   */
+  toAnnotation() {
+    return new listBlock.ImageAnnotation(this.size, this.alt);
+  }
+}
+
+exports.ImageAnnotationAction = ImageAnnotationAction;
 exports.TextColorToolbarButtonSlimmer = TextColorToolbarButtonSlimmer;
+exports.TextNodeRenderingRegistry = TextNodeRenderingRegistry$1;
 exports.ToolbarButtonSlimmer = ToolbarButtonSlimmer;