jky-component-lib 0.0.56 → 0.0.60

package/dist/lib/node_modules/@tinymce/tinymce-vue/lib/es2015/main/ts/Utils.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+var validEvents = [
+  "onActivate",
+  "onAddUndo",
+  "onBeforeAddUndo",
+  "onBeforeExecCommand",
+  "onBeforeGetContent",
+  "onBeforeRenderUI",
+  "onBeforeSetContent",
+  "onBeforePaste",
+  "onBlur",
+  "onChange",
+  "onClearUndos",
+  "onClick",
+  "onContextMenu",
+  "onCommentChange",
+  "onCompositionEnd",
+  "onCompositionStart",
+  "onCompositionUpdate",
+  "onCopy",
+  "onCut",
+  "onDblclick",
+  "onDeactivate",
+  "onDirty",
+  "onDrag",
+  "onDragDrop",
+  "onDragEnd",
+  "onDragGesture",
+  "onDragOver",
+  "onDrop",
+  "onExecCommand",
+  "onFocus",
+  "onFocusIn",
+  "onFocusOut",
+  "onGetContent",
+  "onHide",
+  "onInit",
+  "onInput",
+  "onKeyDown",
+  "onKeyPress",
+  "onKeyUp",
+  "onLoadContent",
+  "onMouseDown",
+  "onMouseEnter",
+  "onMouseLeave",
+  "onMouseMove",
+  "onMouseOut",
+  "onMouseOver",
+  "onMouseUp",
+  "onNodeChange",
+  "onObjectResizeStart",
+  "onObjectResized",
+  "onObjectSelected",
+  "onPaste",
+  "onPostProcess",
+  "onPostRender",
+  "onPreProcess",
+  "onProgressState",
+  "onRedo",
+  "onRemove",
+  "onReset",
+  "onSaveContent",
+  "onSelectionChange",
+  "onSetAttrib",
+  "onSetContent",
+  "onShow",
+  "onSubmit",
+  "onUndo",
+  "onVisualAid"
+];
+var isValidKey = function(key) {
+  return validEvents.map(function(event) {
+    return event.toLowerCase();
+  }).indexOf(key.toLowerCase()) !== -1;
+};
+var bindHandlers = function(initEvent, listeners, editor) {
+  Object.keys(listeners).filter(isValidKey).forEach(function(key) {
+    var handler = listeners[key];
+    if (typeof handler === "function") {
+      if (key === "onInit") {
+        handler(initEvent, editor);
+      } else {
+        editor.on(key.substring(2), function(e) {
+          return handler(e, editor);
+        });
+      }
+    }
+  });
+};
+var bindModelHandlers = function(props, ctx, editor, modelValue) {
+  var modelEvents = props.modelEvents ? props.modelEvents : null;
+  var normalizedEvents = Array.isArray(modelEvents) ? modelEvents.join(" ") : modelEvents;
+  vue.watch(modelValue, function(val, prevVal) {
+    if (editor && typeof val === "string" && val !== prevVal && val !== editor.getContent({ format: props.outputFormat })) {
+      editor.setContent(val);
+    }
+  });
+  editor.on(normalizedEvents ? normalizedEvents : "change input undo redo", function() {
+    ctx.emit("update:modelValue", editor.getContent({ format: props.outputFormat }));
+  });
+};
+var initEditor = function(initEvent, props, ctx, editor, modelValue, content) {
+  editor.setContent(content());
+  if (ctx.attrs["onUpdate:modelValue"]) {
+    bindModelHandlers(props, ctx, editor, modelValue);
+  }
+  bindHandlers(initEvent, ctx.attrs, editor);
+};
+var unique = 0;
+var uuid = function(prefix) {
+  var time = Date.now();
+  var random = Math.floor(Math.random() * 1e9);
+  unique++;
+  return prefix + "_" + random + unique + String(time);
+};
+var isTextarea = function(element) {
+  return element !== null && element.tagName.toLowerCase() === "textarea";
+};
+var normalizePluginArray = function(plugins) {
+  if (typeof plugins === "undefined" || plugins === "") {
+    return [];
+  }
+  return Array.isArray(plugins) ? plugins : plugins.split(" ");
+};
+var mergePlugins = function(initPlugins, inputPlugins) {
+  return normalizePluginArray(initPlugins).concat(normalizePluginArray(inputPlugins));
+};
+var isNullOrUndefined = function(value) {
+  return value === null || value === void 0;
+};
+var isDisabledOptionSupported = function(editor) {
+  var _a;
+  return typeof ((_a = editor.options) === null || _a === void 0 ? void 0 : _a.set) === "function" && editor.options.isRegistered("disabled");
+};
+exports.bindHandlers = bindHandlers;
+exports.bindModelHandlers = bindModelHandlers;
+exports.initEditor = initEditor;
+exports.isDisabledOptionSupported = isDisabledOptionSupported;
+exports.isNullOrUndefined = isNullOrUndefined;
+exports.isTextarea = isTextarea;
+exports.isValidKey = isValidKey;
+exports.mergePlugins = mergePlugins;
+exports.uuid = uuid;

package/dist/lib/node_modules/@tinymce/tinymce-vue/lib/es2015/main/ts/components/Editor.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ScriptLoader = require("../ScriptLoader.js");
+const TinyMCE = require("../TinyMCE.js");
+const Utils = require("../Utils.js");
+const EditorPropTypes = require("./EditorPropTypes.js");
+const vue = require("vue");
+var __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 renderInline = function(ce, id, elementRef, tagName) {
+  return ce(tagName ? tagName : "div", {
+    id,
+    ref: elementRef
+  });
+};
+var renderIframe = function(ce, id, elementRef) {
+  return ce("textarea", {
+    id,
+    visibility: "hidden",
+    ref: elementRef
+  });
+};
+var defaultInitValues = { selector: void 0, target: void 0 };
+var setMode = function(editor, mode) {
+  var _a;
+  if (typeof ((_a = editor.mode) === null || _a === void 0 ? void 0 : _a.set) === "function") {
+    editor.mode.set(mode);
+  } else {
+    editor.setMode(mode);
+  }
+};
+var Editor = vue.defineComponent({
+  props: EditorPropTypes.editorProps,
+  setup: function(props, ctx) {
+    var conf = props.init ? __assign(__assign({}, props.init), defaultInitValues) : __assign({}, defaultInitValues);
+    var _a = vue.toRefs(props), disabled = _a.disabled, readonly = _a.readonly, modelValue = _a.modelValue, tagName = _a.tagName;
+    var element = vue.ref(null);
+    var vueEditor = null;
+    var elementId = props.id || Utils.uuid("tiny-vue");
+    var inlineEditor = props.init && props.init.inline || props.inline;
+    var modelBind = !!ctx.attrs["onUpdate:modelValue"];
+    var mounting = true;
+    var initialValue = props.initialValue ? props.initialValue : "";
+    var cache = "";
+    var getContent = function(isMounting) {
+      return modelBind ? function() {
+        return (modelValue === null || modelValue === void 0 ? void 0 : modelValue.value) ? modelValue.value : "";
+      } : function() {
+        return isMounting ? initialValue : cache;
+      };
+    };
+    var initWrapper = function() {
+      var content = getContent(mounting);
+      var finalInit = __assign(__assign({}, conf), { disabled: props.disabled, readonly: props.readonly, target: element.value, plugins: Utils.mergePlugins(conf.plugins, props.plugins), toolbar: props.toolbar || conf.toolbar, inline: inlineEditor, license_key: props.licenseKey, setup: function(editor) {
+        vueEditor = editor;
+        if (!Utils.isDisabledOptionSupported(vueEditor) && props.disabled === true) {
+          setMode(vueEditor, "readonly");
+        }
+        editor.on("init", function(e) {
+          return Utils.initEditor(e, props, ctx, editor, modelValue, content);
+        });
+        if (typeof conf.setup === "function") {
+          conf.setup(editor);
+        }
+      } });
+      if (Utils.isTextarea(element.value)) {
+        element.value.style.visibility = "";
+      }
+      TinyMCE.getTinymce().init(finalInit);
+      mounting = false;
+    };
+    vue.watch(readonly, function(isReadonly) {
+      if (vueEditor !== null) {
+        setMode(vueEditor, isReadonly ? "readonly" : "design");
+      }
+    });
+    vue.watch(disabled, function(isDisabled) {
+      if (vueEditor !== null) {
+        if (Utils.isDisabledOptionSupported(vueEditor)) {
+          vueEditor.options.set("disabled", isDisabled);
+        } else {
+          setMode(vueEditor, isDisabled ? "readonly" : "design");
+        }
+      }
+    });
+    vue.watch(tagName, function(_) {
+      var _a2;
+      if (vueEditor) {
+        if (!modelBind) {
+          cache = vueEditor.getContent();
+        }
+        (_a2 = TinyMCE.getTinymce()) === null || _a2 === void 0 ? void 0 : _a2.remove(vueEditor);
+        vue.nextTick(function() {
+          return initWrapper();
+        });
+      }
+    });
+    vue.onMounted(function() {
+      if (TinyMCE.getTinymce() !== null) {
+        initWrapper();
+      } else if (element.value && element.value.ownerDocument) {
+        var channel = props.cloudChannel ? props.cloudChannel : "8";
+        var apiKey = props.apiKey ? props.apiKey : "no-api-key";
+        var scriptSrc = Utils.isNullOrUndefined(props.tinymceScriptSrc) ? "https://cdn.tiny.cloud/1/".concat(apiKey, "/tinymce/").concat(channel, "/tinymce.min.js") : props.tinymceScriptSrc;
+        ScriptLoader.ScriptLoader.load(element.value.ownerDocument, scriptSrc, initWrapper);
+      }
+    });
+    vue.onBeforeUnmount(function() {
+      if (TinyMCE.getTinymce() !== null) {
+        TinyMCE.getTinymce().remove(vueEditor);
+      }
+    });
+    if (!inlineEditor) {
+      vue.onActivated(function() {
+        if (!mounting) {
+          initWrapper();
+        }
+      });
+      vue.onDeactivated(function() {
+        var _a2;
+        if (vueEditor) {
+          if (!modelBind) {
+            cache = vueEditor.getContent();
+          }
+          (_a2 = TinyMCE.getTinymce()) === null || _a2 === void 0 ? void 0 : _a2.remove(vueEditor);
+        }
+      });
+    }
+    var rerender = function(init) {
+      var _a2;
+      if (vueEditor) {
+        cache = vueEditor.getContent();
+        (_a2 = TinyMCE.getTinymce()) === null || _a2 === void 0 ? void 0 : _a2.remove(vueEditor);
+        conf = __assign(__assign(__assign({}, conf), init), defaultInitValues);
+        vue.nextTick(function() {
+          return initWrapper();
+        });
+      }
+    };
+    ctx.expose({
+      rerender,
+      getEditor: function() {
+        return vueEditor;
+      }
+    });
+    return function() {
+      return inlineEditor ? renderInline(vue.h, elementId, element, props.tagName) : renderIframe(vue.h, elementId, element);
+    };
+  }
+});
+exports.Editor = Editor;

package/dist/lib/node_modules/@tinymce/tinymce-vue/lib/es2015/main/ts/components/EditorPropTypes.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var editorProps = {
+  apiKey: String,
+  licenseKey: String,
+  cloudChannel: String,
+  id: String,
+  init: Object,
+  initialValue: String,
+  inline: Boolean,
+  modelEvents: [String, Array],
+  plugins: [String, Array],
+  tagName: String,
+  toolbar: [String, Array],
+  modelValue: String,
+  disabled: Boolean,
+  readonly: Boolean,
+  tinymceScriptSrc: String,
+  outputFormat: {
+    type: String,
+    validator: function(prop) {
+      return prop === "html" || prop === "text";
+    }
+  }
+};
+exports.editorProps = editorProps;

package/dist/lib/node_modules/@tinymce/tinymce-vue/lib/es2015/main/ts/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Editor = require("./components/Editor.js");
+exports.default = Editor.Editor;

package/dist/lib/package.json.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const version = "0.0.56";
+const version = "0.0.60";
 exports.version = version;

package/dist/lib/page-header/PopoverMenu.vue.d.ts

@@ -2,9 +2,9 @@ import { TooltipTriggerType } from 'element-plus';
 import { Arrayable } from 'element-plus/es/utils';
 import { PageHeaderPopoverMenuItem, PageHeaderPopoverMenuProps } from './types';
 declare const _default: import('vue').DefineComponent<PageHeaderPopoverMenuProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PageHeaderPopoverMenuProps> & Readonly<{}>, {
+    width: number;
     trigger: Arrayable<TooltipTriggerType>;
     placement: import('element-plus').Placement;
-    width: number;
     menus: PageHeaderPopoverMenuItem[];
     highlightCurrent: boolean;
     buttonClass: string;