@endge/ui-vue 0.23.3

package/dist/revogr-clipboard_3.entry-BRLLR59Q.js

@@ -0,0 +1,334 @@
+import { t as f, r as h, c as n, h as v, a4 as g, H as m, f as y, l as w, a5 as b, q as C, a3 as c } from "./main-CQv-nkoD.js";
+import { d as E, c as D, j as S } from "./edit.utils-Dnnbd0xG-D9ndNtVP.js";
+/*!
+ * Built by Revolist OU ❤️
+ */
+class O {
+  constructor(e, i) {
+    this.data = e, this.saveCallback = i, this.editInput = null, this.element = null, this.editCell = void 0;
+  }
+  /**
+   * Callback triggered on cell editor render
+   */
+  async componentDidRender() {
+    var e;
+    this.editInput && (await f(), (e = this.editInput) === null || e === void 0 || e.focus());
+  }
+  onKeyDown(e) {
+    const i = E(e.key), r = D(e.key);
+    (r || i) && e.target && this.saveCallback && !e.isComposing && (this.beforeDisconnect(), this.saveCallback(this.getValue(), r));
+  }
+  /**
+   * IMPORTANT: Prevent scroll glitches when editor is closed and focus is on current input element.
+   */
+  beforeDisconnect() {
+    var e;
+    (e = this.editInput) === null || e === void 0 || e.blur();
+  }
+  /**
+   * Get value from input
+   */
+  getValue() {
+    var e;
+    return (e = this.editInput) === null || e === void 0 ? void 0 : e.value;
+  }
+  /**
+   * Render method for Editor plugin.
+   * Renders input element with passed data from cell.
+   * @param {Function} h - h function from stencil render.
+   * @param {Object} _additionalData - additional data from plugin.
+   * @returns {VNode} - input element.
+   */
+  render(e, i) {
+    var r, s;
+    return e("input", {
+      type: "text",
+      enterKeyHint: "enter",
+      // set input value from cell data
+      value: (s = (r = this.editCell) === null || r === void 0 ? void 0 : r.val) !== null && s !== void 0 ? s : "",
+      // save input element as ref for further usage
+      ref: (o) => {
+        this.editInput = o;
+      },
+      // listen to keydown event on input element
+      onKeyDown: (o) => this.onKeyDown(o)
+    });
+  }
+}
+/*!
+ * Built by Revolist OU ❤️
+ */
+const A = class {
+  constructor(t) {
+    h(this, t), this.beforePaste = n(this, "beforepaste", 7), this.beforePasteApply = n(this, "beforepasteapply", 7), this.pasteRegion = n(this, "pasteregion", 7), this.afterPasteApply = n(this, "afterpasteapply", 7), this.beforeCut = n(this, "beforecut", 7), this.clearRegion = n(this, "clearregion", 7), this.beforeCopy = n(this, "beforecopy", 7), this.beforeCopyApply = n(this, "beforecopyapply", 7), this.copyRegion = n(this, "copyregion", 7);
+  }
+  onPaste(t) {
+    if (this.readonly)
+      return;
+    const e = this.getData(t), i = ((e == null ? void 0 : e.types.indexOf("text/html")) || -1) > -1, r = (i ? e == null ? void 0 : e.getData("text/html") : e == null ? void 0 : e.getData("text")) || "", s = (e == null ? void 0 : e.getData("text")) || "", o = this.beforePaste.emit({
+      raw: r,
+      dataText: s,
+      isHTML: i,
+      event: t
+    });
+    if (o.defaultPrevented)
+      return;
+    let a;
+    o.detail.isHTML ? a = this.htmlParse(o.detail.raw) || this.textParse(s || "") : a = this.textParse(o.detail.raw);
+    const l = this.beforePasteApply.emit({
+      raw: r,
+      parsed: a,
+      dataText: s,
+      event: t
+    });
+    l.defaultPrevented || (this.pasteRegion.emit(l.detail.parsed), this.afterPasteApply.emit({
+      raw: r,
+      parsed: a,
+      dataText: s,
+      event: t
+    }).defaultPrevented) || t.preventDefault();
+  }
+  /**
+   * Listen to copy event and emit copy region event
+   */
+  copyStarted(t) {
+    const e = this.beforeCopy.emit({
+      event: t
+    });
+    if (e.defaultPrevented)
+      return;
+    const i = this.getData(e.detail.event);
+    t.preventDefault(), this.copyRegion.emit(i || void 0);
+  }
+  /**
+   * Listen to copy event and emit copy region event
+   */
+  cutStarted(t) {
+    const e = this.beforeCut.emit({
+      event: t
+    });
+    if (e.defaultPrevented)
+      return;
+    const i = this.getData(e.detail.event);
+    this.copyStarted(t), !this.readonly && (this.clearRegion.emit(i || void 0), t.preventDefault());
+  }
+  async doCopy(t, e) {
+    if (this.beforeCopyApply.emit({
+      event: t,
+      data: e
+    }).defaultPrevented)
+      return;
+    const r = e ? this.parserCopy(e) : "";
+    t.setData("text/plain", r);
+  }
+  parserCopy(t) {
+    return t.map((e) => e.join("	")).join(`
+`);
+  }
+  textParse(t) {
+    const e = [], i = t.split(/\r\n|\n|\r/);
+    for (let r in i)
+      e.push(i[r].split("	"));
+    return e;
+  }
+  htmlParse(t) {
+    const e = [], r = document.createRange().createContextualFragment(t).querySelector("table");
+    if (!r)
+      return null;
+    for (const s of Array.from(r.rows))
+      e.push(Array.from(s.cells).map((o) => o.innerText));
+    return e;
+  }
+  getData(t) {
+    return t.clipboardData || (globalThis == null ? void 0 : globalThis.clipboardData);
+  }
+}, R = () => "revogr-edit{display:block;position:absolute;background-color:var(--revo-grid-background, #fff)}revogr-edit input{height:100%;width:100%;box-sizing:border-box;background-color:var(--revo-grid-background, transparent)}revogr-edit revo-dropdown{height:100%}revogr-edit revo-dropdown.shrink fieldset legend>span{display:none}", x = class {
+  constructor(t) {
+    h(this, t), this.cellEdit = n(this, "celleditinit", 7), this.closeEdit = n(this, "closeedit", 7), this.saveOnClose = !1, this.currentEditor = null, this.preventSaveOnClose = !1;
+  }
+  /**
+   * Cancel pending changes flag. Editor will be closed without autosave.
+   */
+  async cancelChanges() {
+    this.preventSaveOnClose = !0;
+  }
+  /**
+   * Before editor got disconnected.
+   * Can be triggered multiple times before actual disconnect.
+   */
+  async beforeDisconnect() {
+    var t, e;
+    (e = (t = this.currentEditor) === null || t === void 0 ? void 0 : t.beforeDisconnect) === null || e === void 0 || e.call(t);
+  }
+  onAutoSave() {
+    var t, e, i;
+    this.preventSaveOnClose = !0;
+    const r = (e = (t = this.currentEditor) === null || t === void 0 ? void 0 : t.getValue) === null || e === void 0 ? void 0 : e.call(t);
+    !((i = this.currentEditor) === null || i === void 0) && i.beforeAutoSave && this.currentEditor.beforeAutoSave(r) === !1 || this.onSave(r, !0);
+  }
+  /**
+   * Callback triggered when cell editor saved.
+   * Closes editor when called.
+   * @param preventFocus - if true, editor will not be closed & next cell will not be focused.
+   */
+  onSave(t, e) {
+    this.preventSaveOnClose = !0, this.editCell && this.cellEdit.emit({
+      rgCol: this.editCell.x,
+      rgRow: this.editCell.y,
+      type: this.editCell.type,
+      prop: this.editCell.prop,
+      val: t,
+      preventFocus: e
+    });
+  }
+  componentWillRender() {
+    if (!(this.currentEditor || !this.column)) {
+      if (this.preventSaveOnClose = !1, this.editor) {
+        S(this.editor) ? this.currentEditor = new this.editor(
+          this.column,
+          // save callback
+          (t, e) => {
+            this.onSave(t, e);
+          },
+          // cancel callback
+          (t) => {
+            this.preventSaveOnClose = !0, this.closeEdit.emit(t);
+          }
+        ) : this.currentEditor = this.editor(
+          this.column,
+          // save callback
+          (t, e) => {
+            this.onSave(t, e);
+          },
+          // cancel callback
+          (t) => {
+            this.preventSaveOnClose = !0, this.closeEdit.emit(t);
+          }
+        );
+        return;
+      }
+      this.currentEditor = new O(this.column, (t, e) => this.onSave(t, e));
+    }
+  }
+  componentDidRender() {
+    var t, e;
+    this.currentEditor && (this.currentEditor.element = this.element.firstElementChild, (e = (t = this.currentEditor).componentDidRender) === null || e === void 0 || e.call(t));
+  }
+  disconnectedCallback() {
+    var t, e;
+    this.saveOnClose && (this.preventSaveOnClose || this.onAutoSave()), this.preventSaveOnClose = !1, this.currentEditor && ((e = (t = this.currentEditor).disconnectedCallback) === null || e === void 0 || e.call(t), this.currentEditor.element = null, this.currentEditor = null);
+  }
+  render() {
+    return this.currentEditor ? (this.currentEditor.editCell = this.editCell, v(m, { class: g }, this.currentEditor.render(v, this.additionalData))) : "";
+  }
+  get element() {
+    return y(this);
+  }
+};
+x.style = R();
+class P {
+  constructor(e) {
+    this.config = e, this.currentCell = null, this.previousRow = null;
+  }
+  /** Drag finished, calculate and apply changes */
+  endOrder(e, i) {
+    if (this.currentCell === null)
+      return;
+    const r = this.getCell(e, i);
+    r.y < 0 ? r.y = 0 : r.y < this.currentCell.y && r.y++, r.y !== this.currentCell.y && this.config.positionChanged(this.currentCell.y, r.y), this.clear();
+  }
+  /** Drag started, reserve initial cell for farther use */
+  startOrder(e, i) {
+    return this.currentCell = this.getCell(e, i), this.currentCell;
+  }
+  move(e, i) {
+    const r = this.getRow(e, i);
+    return this.previousRow === r.itemIndex || r.itemIndex < -1 ? null : (this.previousRow = r.itemIndex, r);
+  }
+  /** Drag stopped, probably cursor outside of document area */
+  clear() {
+    this.currentCell = null, this.previousRow = null;
+  }
+  /** Calculate cell based on x, y position */
+  getRow(e, { el: i, rows: r }) {
+    const { top: s } = i.getBoundingClientRect(), o = e - s, a = r.renderOffset || 0, l = c(r, o + a);
+    return {
+      itemIndex: l.itemIndex,
+      start: l.start - a + s,
+      end: l.end - a + s
+    };
+  }
+  /** Calculate cell based on x, y position */
+  getCell({ x: e, y: i }, { el: r, rows: s, cols: o }) {
+    const { top: a, left: l } = r.getBoundingClientRect(), d = i - a, u = e - l, p = c(s, d + (s.renderOffset || 0));
+    return { x: c(o, u + (o.renderOffset || 0)).itemIndex, y: p.itemIndex };
+  }
+}
+const k = class {
+  constructor(t) {
+    h(this, t), this.rowDragStart = n(this, "rowdragstartinit", 7), this.rowDragEnd = n(this, "rowdragendinit", 7), this.rowDrag = n(this, "rowdragmoveinit", 7), this.rowMouseMove = n(this, "rowdragmousemove", 7), this.rowDropped = n(this, "rowdropinit", 7), this.rowOrderChange = n(this, "roworderchange", 7), this.events = [], this.rowMoveFunc = w((e) => {
+      const i = this.rowOrderService.move(e, this.getData());
+      i !== null && this.rowDrag.emit(Object.assign(Object.assign({}, i), { rowType: this.rowType }));
+    }, 5);
+  }
+  // #endregion
+  // #region Methods
+  async dragStart(t) {
+    t.originalEvent.preventDefault(), this.events.length && this.clearOrder();
+    const e = this.getData(), i = this.rowOrderService.startOrder(t.originalEvent, e), r = this.rowOrderService.getRow(t.originalEvent.y, e);
+    if (this.rowDragStart.emit({
+      cell: i,
+      text: b,
+      pos: r,
+      event: t.originalEvent,
+      rowType: this.rowType,
+      model: C(this.dataStore, r.itemIndex)
+    }).defaultPrevented)
+      return;
+    const o = (d) => this.move(d), a = (d) => this.endOrder(d), l = () => this.clearOrder();
+    this.events.push({
+      name: "mousemove",
+      listener: o
+    }, {
+      name: "mouseup",
+      listener: a
+    }, {
+      name: "mouseleave",
+      listener: l
+    }), document.addEventListener("mousemove", o), document.addEventListener("mouseup", a), document.addEventListener("mouseleave", l);
+  }
+  async endOrder(t) {
+    this.rowOrderService.endOrder(t, this.getData()), this.clearOrder();
+  }
+  async clearOrder() {
+    this.rowOrderService.clear(), this.events.forEach((t) => document.removeEventListener(t.name, t.listener)), this.events.length = 0, this.rowDragEnd.emit({ rowType: this.rowType });
+  }
+  // #endregion
+  move({ x: t, y: e }) {
+    this.rowMouseMove.emit({ x: t, y: e, rowType: this.rowType }), this.rowMoveFunc(e);
+  }
+  connectedCallback() {
+    this.rowOrderService = new P({
+      positionChanged: (t, e) => {
+        const i = this.rowDropped.emit({
+          from: t,
+          to: e,
+          rowType: this.rowType
+        });
+        i.defaultPrevented || this.rowOrderChange.emit(i.detail);
+      }
+    });
+  }
+  getData() {
+    return {
+      el: this.parent,
+      rows: this.dimensionRow.state,
+      cols: this.dimensionCol.state
+    };
+  }
+};
+export {
+  A as revogr_clipboard,
+  x as revogr_edit,
+  k as revogr_order_editor
+};