service-flow-designer 0.0.1-beta.0 → 0.0.1-beta.2

package/dist/lib/node_modules/.pnpm/quill@2.0.2/node_modules/quill/modules/toolbar.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Delta = require("../../../../quill-delta@5.1.0/node_modules/quill-delta/dist/Delta.js");
+const parchment = require("../../../../parchment@3.0.0/node_modules/parchment/dist/parchment.js");
+const quill = require("../core/quill.js");
+const logger = require("../core/logger.js");
+const module$1 = require("../core/module.js");
+const debug = logger("quill:toolbar");
+class Toolbar extends module$1 {
+  constructor(quill$1, options) {
+    var _a, _b;
+    super(quill$1, options);
+    if (Array.isArray(this.options.container)) {
+      const container = document.createElement("div");
+      container.setAttribute("role", "toolbar");
+      addControls(container, this.options.container);
+      (_b = (_a = quill$1.container) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.insertBefore(container, quill$1.container);
+      this.container = container;
+    } else if (typeof this.options.container === "string") {
+      this.container = document.querySelector(this.options.container);
+    } else {
+      this.container = this.options.container;
+    }
+    if (!(this.container instanceof HTMLElement)) {
+      debug.error("Container required for toolbar", this.options);
+      return;
+    }
+    this.container.classList.add("ql-toolbar");
+    this.controls = [];
+    this.handlers = {};
+    if (this.options.handlers) {
+      Object.keys(this.options.handlers).forEach((format) => {
+        var _a2;
+        const handler = (_a2 = this.options.handlers) == null ? void 0 : _a2[format];
+        if (handler) {
+          this.addHandler(format, handler);
+        }
+      });
+    }
+    Array.from(this.container.querySelectorAll("button, select")).forEach((input) => {
+      this.attach(input);
+    });
+    this.quill.on(quill.default.events.EDITOR_CHANGE, () => {
+      const [range] = this.quill.selection.getRange();
+      this.update(range);
+    });
+  }
+  addHandler(format, handler) {
+    this.handlers[format] = handler;
+  }
+  attach(input) {
+    let format = Array.from(input.classList).find((className) => {
+      return className.indexOf("ql-") === 0;
+    });
+    if (!format) return;
+    format = format.slice("ql-".length);
+    if (input.tagName === "BUTTON") {
+      input.setAttribute("type", "button");
+    }
+    if (this.handlers[format] == null && this.quill.scroll.query(format) == null) {
+      debug.warn("ignoring attaching to nonexistent format", format, input);
+      return;
+    }
+    const eventName = input.tagName === "SELECT" ? "change" : "click";
+    input.addEventListener(eventName, (e) => {
+      let value;
+      if (input.tagName === "SELECT") {
+        if (input.selectedIndex < 0) return;
+        const selected = input.options[input.selectedIndex];
+        if (selected.hasAttribute("selected")) {
+          value = false;
+        } else {
+          value = selected.value || false;
+        }
+      } else {
+        if (input.classList.contains("ql-active")) {
+          value = false;
+        } else {
+          value = input.value || !input.hasAttribute("value");
+        }
+        e.preventDefault();
+      }
+      this.quill.focus();
+      const [range] = this.quill.selection.getRange();
+      if (this.handlers[format] != null) {
+        this.handlers[format].call(this, value);
+      } else if (
+        // @ts-expect-error
+        this.quill.scroll.query(format).prototype instanceof parchment.EmbedBlot
+      ) {
+        value = prompt(`Enter ${format}`);
+        if (!value) return;
+        this.quill.updateContents(new Delta.default().retain(range.index).delete(range.length).insert({
+          [format]: value
+        }), quill.default.sources.USER);
+      } else {
+        this.quill.format(format, value, quill.default.sources.USER);
+      }
+      this.update(range);
+    });
+    this.controls.push([format, input]);
+  }
+  update(range) {
+    const formats = range == null ? {} : this.quill.getFormat(range);
+    this.controls.forEach((pair) => {
+      const [format, input] = pair;
+      if (input.tagName === "SELECT") {
+        let option = null;
+        if (range == null) {
+          option = null;
+        } else if (formats[format] == null) {
+          option = input.querySelector("option[selected]");
+        } else if (!Array.isArray(formats[format])) {
+          let value = formats[format];
+          if (typeof value === "string") {
+            value = value.replace(/"/g, '\\"');
+          }
+          option = input.querySelector(`option[value="${value}"]`);
+        }
+        if (option == null) {
+          input.value = "";
+          input.selectedIndex = -1;
+        } else {
+          option.selected = true;
+        }
+      } else if (range == null) {
+        input.classList.remove("ql-active");
+        input.setAttribute("aria-pressed", "false");
+      } else if (input.hasAttribute("value")) {
+        const value = formats[format];
+        const isActive = value === input.getAttribute("value") || value != null && value.toString() === input.getAttribute("value") || value == null && !input.getAttribute("value");
+        input.classList.toggle("ql-active", isActive);
+        input.setAttribute("aria-pressed", isActive.toString());
+      } else {
+        const isActive = formats[format] != null;
+        input.classList.toggle("ql-active", isActive);
+        input.setAttribute("aria-pressed", isActive.toString());
+      }
+    });
+  }
+}
+Toolbar.DEFAULTS = {};
+function addButton(container, format, value) {
+  const input = document.createElement("button");
+  input.setAttribute("type", "button");
+  input.classList.add(`ql-${format}`);
+  input.setAttribute("aria-pressed", "false");
+  if (value != null) {
+    input.value = value;
+    input.setAttribute("aria-label", `${format}: ${value}`);
+  } else {
+    input.setAttribute("aria-label", format);
+  }
+  container.appendChild(input);
+}
+function addControls(container, groups) {
+  if (!Array.isArray(groups[0])) {
+    groups = [groups];
+  }
+  groups.forEach((controls) => {
+    const group = document.createElement("span");
+    group.classList.add("ql-formats");
+    controls.forEach((control) => {
+      if (typeof control === "string") {
+        addButton(group, control);
+      } else {
+        const format = Object.keys(control)[0];
+        const value = control[format];
+        if (Array.isArray(value)) {
+          addSelect(group, format, value);
+        } else {
+          addButton(group, format, value);
+        }
+      }
+    });
+    container.appendChild(group);
+  });
+}
+function addSelect(container, format, values) {
+  const input = document.createElement("select");
+  input.classList.add(`ql-${format}`);
+  values.forEach((value) => {
+    const option = document.createElement("option");
+    if (value !== false) {
+      option.setAttribute("value", String(value));
+    } else {
+      option.setAttribute("selected", "selected");
+    }
+    input.appendChild(option);
+  });
+  container.appendChild(input);
+}
+Toolbar.DEFAULTS = {
+  container: null,
+  handlers: {
+    clean() {
+      const range = this.quill.getSelection();
+      if (range == null) return;
+      if (range.length === 0) {
+        const formats = this.quill.getFormat();
+        Object.keys(formats).forEach((name) => {
+          if (this.quill.scroll.query(name, parchment.Scope.INLINE) != null) {
+            this.quill.format(name, false, quill.default.sources.USER);
+          }
+        });
+      } else {
+        this.quill.removeFormat(range.index, range.length, quill.default.sources.USER);
+      }
+    },
+    direction(value) {
+      const {
+        align
+      } = this.quill.getFormat();
+      if (value === "rtl" && align == null) {
+        this.quill.format("align", "right", quill.default.sources.USER);
+      } else if (!value && align === "right") {
+        this.quill.format("align", false, quill.default.sources.USER);
+      }
+      this.quill.format("direction", value, quill.default.sources.USER);
+    },
+    indent(value) {
+      const range = this.quill.getSelection();
+      const formats = this.quill.getFormat(range);
+      const indent = parseInt(formats.indent || 0, 10);
+      if (value === "+1" || value === "-1") {
+        let modifier = value === "+1" ? 1 : -1;
+        if (formats.direction === "rtl") modifier *= -1;
+        this.quill.format("indent", indent + modifier, quill.default.sources.USER);
+      }
+    },
+    link(value) {
+      if (value === true) {
+        value = prompt("Enter link URL:");
+      }
+      this.quill.format("link", value, quill.default.sources.USER);
+    },
+    list(value) {
+      const range = this.quill.getSelection();
+      const formats = this.quill.getFormat(range);
+      if (value === "check") {
+        if (formats.list === "checked" || formats.list === "unchecked") {
+          this.quill.format("list", false, quill.default.sources.USER);
+        } else {
+          this.quill.format("list", "unchecked", quill.default.sources.USER);
+        }
+      } else {
+        this.quill.format("list", value, quill.default.sources.USER);
+      }
+    }
+  }
+};
+exports.addControls = addControls;
+exports.default = Toolbar;

package/dist/lib/node_modules/.pnpm/quill@2.0.2/node_modules/quill/modules/uiNode.js

@@ -0,0 +1,93 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const parchment = require("../../../../parchment@3.0.0/node_modules/parchment/dist/parchment.js");
+const module$1 = require("../core/module.js");
+const quill = require("../core/quill.js");
+const isMac = /Mac/i.test(navigator.platform);
+const TTL_FOR_VALID_SELECTION_CHANGE = 100;
+const canMoveCaretBeforeUINode = (event) => {
+  if (event.key === "ArrowLeft" || event.key === "ArrowRight" || // RTL scripts or moving from the end of the previous line
+  event.key === "ArrowUp" || event.key === "ArrowDown" || event.key === "Home") {
+    return true;
+  }
+  if (isMac && event.key === "a" && event.ctrlKey === true) {
+    return true;
+  }
+  return false;
+};
+class UINode extends module$1 {
+  constructor(quill2, options) {
+    super(quill2, options);
+    __publicField(this, "isListening", false);
+    __publicField(this, "selectionChangeDeadline", 0);
+    this.handleArrowKeys();
+    this.handleNavigationShortcuts();
+  }
+  handleArrowKeys() {
+    this.quill.keyboard.addBinding({
+      key: ["ArrowLeft", "ArrowRight"],
+      offset: 0,
+      shiftKey: null,
+      handler(range, _ref) {
+        let {
+          line,
+          event
+        } = _ref;
+        if (!(line instanceof parchment.ParentBlot) || !line.uiNode) {
+          return true;
+        }
+        const isRTL = getComputedStyle(line.domNode)["direction"] === "rtl";
+        if (isRTL && event.key !== "ArrowRight" || !isRTL && event.key !== "ArrowLeft") {
+          return true;
+        }
+        this.quill.setSelection(range.index - 1, range.length + (event.shiftKey ? 1 : 0), quill.default.sources.USER);
+        return false;
+      }
+    });
+  }
+  handleNavigationShortcuts() {
+    this.quill.root.addEventListener("keydown", (event) => {
+      if (!event.defaultPrevented && canMoveCaretBeforeUINode(event)) {
+        this.ensureListeningToSelectionChange();
+      }
+    });
+  }
+  /**
+   * We only listen to the `selectionchange` event when
+   * there is an intention of moving the caret to the beginning using shortcuts.
+   * This is primarily implemented to prevent infinite loops, as we are changing
+   * the selection within the handler of a `selectionchange` event.
+   */
+  ensureListeningToSelectionChange() {
+    this.selectionChangeDeadline = Date.now() + TTL_FOR_VALID_SELECTION_CHANGE;
+    if (this.isListening) return;
+    this.isListening = true;
+    const listener = () => {
+      this.isListening = false;
+      if (Date.now() <= this.selectionChangeDeadline) {
+        this.handleSelectionChange();
+      }
+    };
+    document.addEventListener("selectionchange", listener, {
+      once: true
+    });
+  }
+  handleSelectionChange() {
+    const selection = document.getSelection();
+    if (!selection) return;
+    const range = selection.getRangeAt(0);
+    if (range.collapsed !== true || range.startOffset !== 0) return;
+    const line = this.quill.scroll.find(range.startContainer);
+    if (!(line instanceof parchment.ParentBlot) || !line.uiNode) return;
+    const newRange = document.createRange();
+    newRange.setStartAfter(line.uiNode);
+    newRange.setEndAfter(line.uiNode);
+    selection.removeAllRanges();
+    selection.addRange(newRange);
+  }
+}
+exports.TTL_FOR_VALID_SELECTION_CHANGE = TTL_FOR_VALID_SELECTION_CHANGE;
+exports.default = UINode;

package/dist/lib/node_modules/.pnpm/quill@2.0.2/node_modules/quill/modules/uploader.js

@@ -0,0 +1,68 @@
+"use strict";
+const Delta = require("../../../../quill-delta@5.1.0/node_modules/quill-delta/dist/Delta.js");
+const emitter = require("../core/emitter.js");
+const module$1 = require("../core/module.js");
+class Uploader extends module$1 {
+  constructor(quill, options) {
+    super(quill, options);
+    quill.root.addEventListener("drop", (e) => {
+      var _a;
+      e.preventDefault();
+      let native = null;
+      if (document.caretRangeFromPoint) {
+        native = document.caretRangeFromPoint(e.clientX, e.clientY);
+      } else if (document.caretPositionFromPoint) {
+        const position = document.caretPositionFromPoint(e.clientX, e.clientY);
+        native = document.createRange();
+        native.setStart(position.offsetNode, position.offset);
+        native.setEnd(position.offsetNode, position.offset);
+      }
+      const normalized = native && quill.selection.normalizeNative(native);
+      if (normalized) {
+        const range = quill.selection.normalizedToRange(normalized);
+        if ((_a = e.dataTransfer) == null ? void 0 : _a.files) {
+          this.upload(range, e.dataTransfer.files);
+        }
+      }
+    });
+  }
+  upload(range, files) {
+    const uploads = [];
+    Array.from(files).forEach((file) => {
+      var _a;
+      if (file && ((_a = this.options.mimetypes) == null ? void 0 : _a.includes(file.type))) {
+        uploads.push(file);
+      }
+    });
+    if (uploads.length > 0) {
+      this.options.handler.call(this, range, uploads);
+    }
+  }
+}
+Uploader.DEFAULTS = {
+  mimetypes: ["image/png", "image/jpeg"],
+  handler(range, files) {
+    if (!this.quill.scroll.query("image")) {
+      return;
+    }
+    const promises = files.map((file) => {
+      return new Promise((resolve) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+          resolve(reader.result);
+        };
+        reader.readAsDataURL(file);
+      });
+    });
+    Promise.all(promises).then((images) => {
+      const update = images.reduce((delta, image) => {
+        return delta.insert({
+          image
+        });
+      }, new Delta.default().retain(range.index).delete(range.length));
+      this.quill.updateContents(update, emitter.sources.USER);
+      this.quill.setSelection(range.index + images.length, emitter.sources.SILENT);
+    });
+  }
+};
+module.exports = Uploader;

package/dist/lib/node_modules/.pnpm/quill@2.0.2/node_modules/quill/quill.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+require("./core.js");
+const align = require("./formats/align.js");
+const direction = require("./formats/direction.js");
+const indent = require("./formats/indent.js");
+const blockquote = require("./formats/blockquote.js");
+const header = require("./formats/header.js");
+const list = require("./formats/list.js");
+const background = require("./formats/background.js");
+const color = require("./formats/color.js");
+const font = require("./formats/font.js");
+const size = require("./formats/size.js");
+const bold = require("./formats/bold.js");
+const italic = require("./formats/italic.js");
+const link = require("./formats/link.js");
+const script = require("./formats/script.js");
+const strike = require("./formats/strike.js");
+const underline = require("./formats/underline.js");
+const formula = require("./formats/formula.js");
+const image = require("./formats/image.js");
+const video = require("./formats/video.js");
+const code = require("./formats/code.js");
+const syntax = require("./modules/syntax.js");
+const table = require("./modules/table.js");
+const toolbar = require("./modules/toolbar.js");
+const icons = require("./ui/icons.js");
+const picker = require("./ui/picker.js");
+const colorPicker = require("./ui/color-picker.js");
+const iconPicker = require("./ui/icon-picker.js");
+const tooltip = require("./ui/tooltip.js");
+const bubble = require("./themes/bubble.js");
+const snow = require("./themes/snow.js");
+const quill = require("./core/quill.js");
+quill.default.register({
+  "attributors/attribute/direction": direction.DirectionAttribute,
+  "attributors/class/align": align.AlignClass,
+  "attributors/class/background": background.BackgroundClass,
+  "attributors/class/color": color.ColorClass,
+  "attributors/class/direction": direction.DirectionClass,
+  "attributors/class/font": font.FontClass,
+  "attributors/class/size": size.SizeClass,
+  "attributors/style/align": align.AlignStyle,
+  "attributors/style/background": background.BackgroundStyle,
+  "attributors/style/color": color.ColorStyle,
+  "attributors/style/direction": direction.DirectionStyle,
+  "attributors/style/font": font.FontStyle,
+  "attributors/style/size": size.SizeStyle
+}, true);
+quill.default.register({
+  "formats/align": align.AlignClass,
+  "formats/direction": direction.DirectionClass,
+  "formats/indent": indent,
+  "formats/background": background.BackgroundStyle,
+  "formats/color": color.ColorStyle,
+  "formats/font": font.FontClass,
+  "formats/size": size.SizeClass,
+  "formats/blockquote": blockquote,
+  "formats/code-block": code.default,
+  "formats/header": header,
+  "formats/list": list.default,
+  "formats/bold": bold,
+  "formats/code": code.Code,
+  "formats/italic": italic,
+  "formats/link": link.default,
+  "formats/script": script,
+  "formats/strike": strike,
+  "formats/underline": underline,
+  "formats/formula": formula,
+  "formats/image": image,
+  "formats/video": video,
+  "modules/syntax": syntax.default,
+  "modules/table": table,
+  "modules/toolbar": toolbar.default,
+  "themes/bubble": bubble.default,
+  "themes/snow": snow,
+  "ui/icons": icons,
+  "ui/picker": picker,
+  "ui/icon-picker": iconPicker,
+  "ui/color-picker": colorPicker,
+  "ui/tooltip": tooltip
+}, true);
+exports.default = quill.default;