@progress/kendo-vue-editor 2.7.1 → 2.7.2-dev.202201020746

package/dist/es/tools/Indent.js

@@ -0,0 +1,127 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+import { Button as kbutton } from '@progress/kendo-vue-buttons';
+import { indentBlocks, isIndented, canIndentAsListItem, hasNode, sinkListItem } from '@progress/kendo-editor-common';
+import { provideLocalizationService } from '@progress/kendo-vue-intl';
+import { messages } from './../messages'; // tslint:enable:max-line-length
+
+var Indent = {
+  name: 'KendoIndent',
+  props: __assign({
+    view: Object,
+    settings: {
+      type: Object,
+      default: function _default() {
+        return {
+          messages: {}
+        };
+      }
+    }
+  }, kbutton.props),
+  inject: {
+    kendoLocalizationService: {
+      default: null
+    }
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+
+    var _a = this.$props,
+        view = _a.view,
+        render = _a.render,
+        settings = _a.settings,
+        other = __rest(_a, ["view", "render", "settings"]);
+
+    var state = view && view.state;
+    var nodes = state && state.schema.nodes;
+    var listItem = nodes && nodes[settings.listsTypes.listItem];
+    var actions = settings.actions;
+    var canIndented = !!state && (isIndented(state, actions, other.dir) || actions.some(function (a) {
+      return nodes[a.node] && hasNode(state, nodes[a.node]);
+    })) && !hasNode(state, listItem);
+    var canListIndent = !!state && canIndentAsListItem(state, listItem);
+    var canIndent = canIndented || canListIndent;
+    var localization = provideLocalizationService(this);
+    var titleKey = settings.messages.title;
+
+    var buttonProps = __assign(__assign(__assign({}, other), settings.props), {
+      disabled: !canIndent,
+      title: localization.toLanguageString(titleKey, messages[titleKey])
+    });
+
+    var button = h(kbutton, __assign({
+      onClick: this.handleClick,
+      onMousedown: this.preventDefault,
+      onPointerdown: this.preventDefault,
+      on: this.v3 ? undefined : {
+        'click': this.handleClick,
+        'mousedown': this.preventDefault,
+        'pointerdown': this.preventDefault
+      },
+      attrs: this.v3 ? undefined : buttonProps
+    }, buttonProps));
+    return button;
+  },
+  methods: {
+    handleClick: function handleClick() {
+      var state = this.view && this.view.state;
+      var nodes = state && state.schema.nodes;
+      var listItem = nodes && nodes[this.settings.listsTypes.listItem];
+      var actions = this.settings.actions;
+      var canIndented = !!state && (isIndented(state, actions, this.dir) || actions.some(function (a) {
+        return nodes[a.node] && hasNode(state, nodes[a.node]);
+      })) && !hasNode(state, listItem);
+      var canListIndent = !!state && canIndentAsListItem(state, listItem);
+
+      if (this.view && canListIndent) {
+        sinkListItem(listItem)(this.view.state, this.view.dispatch);
+      } else if (this.view && canIndented) {
+        indentBlocks(actions, this.settings.commandName, this.dir)(this.view.state, this.view.dispatch);
+      }
+    },
+    preventDefault: function preventDefault(e) {
+      e.preventDefault();
+    }
+  }
+};
+var IndentVue3 = Indent;
+export { Indent, IndentVue3 };

package/dist/es/tools/InlineFormat.d.ts

@@ -0,0 +1,72 @@
+import { DefineComponent } from '../additionalTypes';
+import { RecordPropsDefinition, ComponentOptions } from 'vue/types/options';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { ToolProps } from './ToolProps';
+/**
+ * @hidden
+ */
+export interface InlineFormatToolProps extends ToolProps {
+}
+/**
+ * @hidden
+ */
+export interface BoldProps extends InlineFormatToolProps {
+}
+/**
+ * @hidden
+ */
+export interface ItalicProps extends InlineFormatToolProps {
+}
+/**
+ * @hidden
+ */
+export interface UnderlineProps extends InlineFormatToolProps {
+}
+/**
+ * @hidden
+ */
+export interface StrikethroughProps extends InlineFormatToolProps {
+}
+/**
+ * @hidden
+ */
+export interface SubscriptProps extends InlineFormatToolProps {
+}
+/**
+ * @hidden
+ */
+export interface SuperscriptProps extends InlineFormatToolProps {
+}
+/**
+ * @hidden
+ */
+export interface InlineFormatState {
+}
+/**
+ * @hidden
+ */
+export interface InlineFormatComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface InlineFormatMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface InlineFormatData {
+}
+/**
+ * @hidden
+ */
+export interface InlineFormatAll extends Vue, InlineFormatMethods, InlineFormatData, InlineFormatComputed, InlineFormatState {
+}
+declare let InlineFormat: ComponentOptions<InlineFormatAll, DefaultData<InlineFormatData>, DefaultMethods<InlineFormatAll>, InlineFormatComputed, RecordPropsDefinition<InlineFormatToolProps>>;
+declare const InlineFormatVue3: DefineComponent<InlineFormatToolProps, any, InlineFormatData, InlineFormatComputed, InlineFormatMethods, {}, {}, {}, string, InlineFormatToolProps, InlineFormatToolProps, {}>;
+export { InlineFormat, InlineFormatVue3 };

package/dist/es/tools/InlineFormat.js

@@ -0,0 +1,125 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+import { Button as kbutton } from '@progress/kendo-vue-buttons';
+import { toggleInlineFormat, hasMark } from '@progress/kendo-editor-common';
+import { provideLocalizationService } from '@progress/kendo-vue-intl';
+import { messages } from '../messages'; // tslint:enable:max-line-length
+
+var InlineFormat = {
+  name: 'KendoInlineFormat',
+  props: __assign({
+    view: Object,
+    settings: {
+      type: Object,
+      default: function _default() {
+        return {
+          messages: {}
+        };
+      }
+    }
+  }, kbutton.props),
+  inject: {
+    kendoLocalizationService: {
+      default: null
+    }
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+
+    var _a = this.$props,
+        view = _a.view,
+        render = _a.render,
+        settings = _a.settings,
+        other = __rest(_a, ["view", "render", "settings"]);
+
+    var state = view && view.state;
+    var mark = settings.mark,
+        altMarks = settings.altMarks,
+        altStyle = settings.altStyle;
+    var options = {
+      mark: mark,
+      altMarks: altMarks,
+      altStyle: altStyle
+    };
+    var localization = provideLocalizationService(this);
+    var titleKey = settings.messages.title;
+
+    var buttonProps = __assign(__assign(__assign({}, other), settings.props), {
+      selected: !!state && hasMark(state, options),
+      togglable: true,
+      title: localization.toLanguageString(titleKey, messages[titleKey])
+    });
+
+    var button = h(kbutton, __assign({
+      onClick: this.handleClick,
+      onMousedown: this.preventDefault,
+      onPointerdown: this.preventDefault,
+      on: this.v3 ? undefined : {
+        'click': this.handleClick,
+        'mousedown': this.preventDefault,
+        'pointerdown': this.preventDefault
+      },
+      attrs: this.v3 ? undefined : buttonProps
+    }, buttonProps));
+    return button;
+  },
+  methods: {
+    handleClick: function handleClick() {
+      var state = this.view && this.view.state;
+      var _a = this.settings,
+          mark = _a.mark,
+          altMarks = _a.altMarks,
+          altStyle = _a.altStyle;
+      var options = {
+        mark: mark,
+        altMarks: altMarks,
+        altStyle: altStyle
+      };
+      return this.view && toggleInlineFormat(options, state && state.tr.setMeta('commandName', this.settings.commandName))(this.view.state, this.view.dispatch);
+    },
+    preventDefault: function preventDefault(e) {
+      e.preventDefault();
+    }
+  }
+};
+var InlineFormatVue3 = InlineFormat;
+export { InlineFormat, InlineFormatVue3 };

package/dist/es/tools/Outdent.d.ts

@@ -0,0 +1,42 @@
+import { DefineComponent } from '../additionalTypes';
+import { RecordPropsDefinition, ComponentOptions } from 'vue/types/options';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { IndentProps } from './indent';
+/**
+ * @hidden
+ */
+export interface OutdentProps extends IndentProps {
+}
+/**
+ * @hidden
+ */
+export interface OutdentState {
+}
+/**
+ * @hidden
+ */
+export interface OutdentComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface OutdentMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface OutdentData {
+}
+/**
+ * @hidden
+ */
+export interface OutdentAll extends Vue, OutdentMethods, OutdentData, OutdentComputed, OutdentState {
+}
+declare let Outdent: ComponentOptions<OutdentAll, DefaultData<OutdentData>, DefaultMethods<OutdentAll>, OutdentComputed, RecordPropsDefinition<OutdentProps>>;
+declare const OutdentVue3: DefineComponent<OutdentProps, any, OutdentData, OutdentComputed, OutdentMethods, {}, {}, {}, string, OutdentProps, OutdentProps, {}>;
+export { Outdent, OutdentVue3 };

package/dist/es/tools/Outdent.js

@@ -0,0 +1,129 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __rest = this && this.__rest || function (s, e) {
+  var t = {};
+
+  for (var p in s) {
+    if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
+  }
+
+  if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+    if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
+  }
+  return t;
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+import { Button as kbutton } from '@progress/kendo-vue-buttons';
+import { indentBlocks, isIndented, canOutdentAsListItem, liftListItem } from '@progress/kendo-editor-common';
+import { provideLocalizationService } from '@progress/kendo-vue-intl';
+import { messages } from './../messages'; // tslint:enable:max-line-length
+
+var Outdent = {
+  name: 'KendoOutdent',
+  props: __assign({
+    view: Object,
+    settings: {
+      type: Object,
+      default: function _default() {
+        return {
+          messages: {}
+        };
+      }
+    }
+  }, kbutton.props),
+  inject: {
+    kendoLocalizationService: {
+      default: null
+    }
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+
+    var _a = this.$props,
+        view = _a.view,
+        render = _a.render,
+        settings = _a.settings,
+        other = __rest(_a, ["view", "render", "settings"]);
+
+    var state = view && view.state;
+    var indented = !!state && isIndented(state, settings.actions, other.dir);
+    var listItem = state && state.schema.nodes[settings.listsTypes.listItem];
+    var canListOutdent = !!state && canOutdentAsListItem(state, {
+      nodes: settings.actions,
+      listsTypes: settings.listsTypes
+    });
+    var canOutdent = indented || canListOutdent;
+    var localization = provideLocalizationService(this);
+    var titleKey = settings.messages.title;
+
+    var buttonProps = __assign(__assign(__assign({}, other), settings.props), {
+      disabled: !canOutdent,
+      title: localization.toLanguageString(titleKey, messages[titleKey])
+    });
+
+    var button = h(kbutton, __assign({
+      onClick: this.handleClick,
+      onMousedown: this.preventDefault,
+      onPointerdown: this.preventDefault,
+      on: this.v3 ? undefined : {
+        'click': this.handleClick,
+        'mousedown': this.preventDefault,
+        'pointerdown': this.preventDefault
+      },
+      attrs: this.v3 ? undefined : buttonProps
+    }, buttonProps));
+    return button;
+  },
+  methods: {
+    handleClick: function handleClick() {
+      var _a = this.$props,
+          view = _a.view,
+          settings = _a.settings,
+          dir = _a.dir;
+      var state = view && view.state;
+      var indented = !!state && isIndented(state, settings.actions, dir);
+      var listItem = state && state.schema.nodes[settings.listsTypes.listItem];
+      var canListOutdent = !!state && canOutdentAsListItem(state, {
+        nodes: settings.actions,
+        listsTypes: settings.listsTypes
+      });
+
+      if (view && canListOutdent) {
+        liftListItem(listItem)(view.state, view.dispatch);
+      } else if (view && indented) {
+        indentBlocks(settings.actions, settings.commandName, dir)(view.state, view.dispatch);
+      }
+    },
+    preventDefault: function preventDefault(e) {
+      e.preventDefault();
+    }
+  }
+};
+var OutdentVue3 = Outdent;
+export { Outdent, OutdentVue3 };

package/dist/es/tools/ToolProps.d.ts

@@ -0,0 +1,34 @@
+import { EditorView } from '@progress/kendo-editor-common';
+import { ButtonProps } from '@progress/kendo-vue-buttons';
+/**
+ * @hidden
+ */
+export interface BasicToolProps {
+    /**
+     * The `EditorView` object of the Editor component.
+     */
+    view?: EditorView;
+}
+/**
+ * @hidden
+ */
+export interface ToolProps extends BasicToolProps, ToolRenderProp, ButtonProps {
+}
+/**
+ * @hidden
+ */
+export interface ToolRenderProp {
+    /**
+     * Fires when a tool is about to be rendered. Used to override the default appearance of the tool.
+     */
+    settings?: any;
+}
+/**
+ * @hidden
+ */
+export interface ToolWithDialogRenderProp {
+    /**
+     * Fires when a tool is about to be rendered. Used to override the default appearance of the tool.
+     */
+    render?: (tool: [], args?: any) => any;
+}

package/dist/es/tools/applyColor.d.ts

@@ -0,0 +1,43 @@
+import { DefineComponent } from '../additionalTypes';
+import { RecordPropsDefinition, ComponentOptions } from 'vue/types/options';
+declare type DefaultData<V> = object | ((this: V) => {});
+declare type DefaultMethods<V> = {
+    [key: string]: (this: V, ...args: any[]) => any;
+};
+import { EditorToolsSettings } from '../config/toolsSettings';
+import { BasicToolProps } from './ToolProps';
+/**
+ * @hidden
+ */
+export interface ApplyColorToolProps extends BasicToolProps, EditorToolsSettings.ApplyColorSettings {
+}
+/**
+ * @hidden
+ */
+export interface ApplyColorState {
+}
+/**
+ * @hidden
+ */
+export interface ApplyColorComputed {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface ApplyColorMethods {
+    [key: string]: any;
+}
+/**
+ * @hidden
+ */
+export interface ApplyColorData {
+}
+/**
+ * @hidden
+ */
+export interface ApplyColorAll extends Vue, ApplyColorMethods, ApplyColorData, ApplyColorComputed, ApplyColorState {
+}
+declare let ApplyColor: ComponentOptions<ApplyColorAll, DefaultData<ApplyColorData>, DefaultMethods<ApplyColorAll>, ApplyColorComputed, RecordPropsDefinition<ApplyColorToolProps>>;
+declare const ApplyColorVue3: DefineComponent<ApplyColorToolProps, any, ApplyColorData, ApplyColorComputed, ApplyColorMethods, {}, {}, {}, string, ApplyColorToolProps, ApplyColorToolProps, {}>;
+export { ApplyColor, ApplyColorVue3 };

package/dist/es/tools/applyColor.js

@@ -0,0 +1,92 @@
+var __assign = this && this.__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+}; // @ts-ignore
+
+
+import * as Vue from 'vue';
+var allVue = Vue;
+var gh = allVue.h;
+import { ColorPicker } from '@progress/kendo-vue-inputs';
+import { applyInlineStyle } from '@progress/kendo-editor-common';
+import { provideLocalizationService } from '@progress/kendo-vue-intl';
+import { messages } from '../messages'; // tslint:enable:max-line-length
+
+var ApplyColor = {
+  name: 'KendoApplyColor',
+  props: {
+    view: Object,
+    color: String,
+    colorPickerProps: Object,
+    commandName: String
+  },
+  inject: {
+    kendoLocalizationService: {
+      default: null
+    }
+  },
+  // @ts-ignore
+  setup: !gh ? undefined : function () {
+    var v3 = !!gh;
+    return {
+      v3: v3
+    };
+  },
+  // @ts-ignore
+  render: function render(createElement) {
+    var h = gh || createElement;
+    var colorPickerProps = this.$props.colorPickerProps;
+    var titleKey = colorPickerProps.title;
+    var localization = provideLocalizationService(this);
+
+    var cpProps = __assign(__assign({}, colorPickerProps), {
+      title: titleKey ? localization.toLanguageString(titleKey, messages[titleKey]) : titleKey
+    });
+
+    var cp = h(ColorPicker, __assign({
+      onChange: this.onChange,
+      onActivecolorclick: this.onChange,
+      on: this.v3 ? undefined : {
+        'change': this.onChange,
+        'activecolorclick': this.onChange
+      },
+      attrs: this.v3 ? undefined : cpProps
+    }, cpProps));
+    return cp;
+  },
+  methods: {
+    onChange: function onChange(event) {
+      var _a = this.$props,
+          view = _a.view,
+          color = _a.color,
+          colorPickerProps = _a.colorPickerProps,
+          commandName = _a.commandName;
+
+      if (view) {
+        applyInlineStyle({
+          style: color,
+          value: event.value
+        }, commandName)(view.state, view.dispatch);
+        var _b = colorPickerProps.view,
+            paletteView = _b === void 0 ? 'palette' : _b;
+
+        if (paletteView === 'palette') {
+          view.focus();
+        }
+      }
+    }
+  }
+};
+var ApplyColorVue3 = ApplyColor;
+export { ApplyColor, ApplyColorVue3 };