@unicom-cloud/ui 0.8.115 → 0.8.117

package/rich-text/lib/parchment/attributor/attributor.js

@@ -0,0 +1,33 @@
+/* 2025-11-03 10:27:46 */
+import "../../../../dist/ui-common/utils/is.js";
+import r from "../scope.js";
+import { isString as a } from "@unicom-cloud/utils/is";
+class m {
+  constructor(e, t, i = {}) {
+    this.attrName = e, this.keyName = t;
+    const s = r.TYPE & r.ATTRIBUTE;
+    this.scope = i.scope != null ? (
+      // Ignore type bits, force attribute bit
+      i.scope & r.LEVEL | s
+    ) : r.ATTRIBUTE, i.whitelist != null && (this.whitelist = i.whitelist);
+  }
+  static keys(e) {
+    return Array.from(e.attributes).map((t) => t.name);
+  }
+  add(e, t) {
+    return this.canAdd(e, t) ? (e.setAttribute(this.keyName, t), !0) : !1;
+  }
+  canAdd(e, t) {
+    return this.whitelist == null ? !0 : a(t) ? this.whitelist.indexOf(t.replace(/["']/g, "")) > -1 : this.whitelist.indexOf(t) > -1;
+  }
+  remove(e) {
+    e.removeAttribute(this.keyName);
+  }
+  value(e) {
+    const t = e.getAttribute(this.keyName);
+    return this.canAdd(e, t) && t ? t : "";
+  }
+}
+export {
+  m as default
+};

package/rich-text/lib/parchment/attributor/class.js

@@ -0,0 +1,25 @@
+/* 2025-11-03 10:27:46 */
+import i from "./attributor.js";
+function r(a, t) {
+  return (a.getAttribute("class") || "").split(/\s+/).filter((e) => e.startsWith(`${t}-`));
+}
+class l extends i {
+  static keys(t) {
+    return (t.getAttribute("class") || "").split(/\s+/).map((s) => s.split("-").slice(0, -1).join("-"));
+  }
+  add(t, s) {
+    return this.canAdd(t, s) ? (this.remove(t), t.classList.add(`${this.keyName}-${s}`), !0) : !1;
+  }
+  remove(t) {
+    r(t, this.keyName).forEach((e) => {
+      t.classList.remove(e);
+    }), t.classList.length === 0 && t.removeAttribute("class");
+  }
+  value(t) {
+    const e = (r(t, this.keyName)[0] || "").slice(this.keyName.length + 1);
+    return this.canAdd(t, e) ? e : "";
+  }
+}
+export {
+  l as default
+};

package/rich-text/lib/parchment/attributor/store.js

@@ -0,0 +1,45 @@
+/* 2025-11-03 10:27:46 */
+import d from "../registry.js";
+import h from "../scope.js";
+import i from "./attributor.js";
+import m from "./class.js";
+import u from "./style.js";
+class y {
+  constructor(t) {
+    this.attributes = {}, this.domNode = t, this.build();
+  }
+  attribute(t, s) {
+    s ? t.add(this.domNode, s) && (t.value(this.domNode) != null ? this.attributes[t.attrName] = t : delete this.attributes[t.attrName]) : (t.remove(this.domNode), delete this.attributes[t.attrName]);
+  }
+  build() {
+    this.attributes = {};
+    const t = d.find(this.domNode);
+    if (t == null)
+      return;
+    const s = i.keys(this.domNode), e = m.keys(this.domNode), r = u.keys(this.domNode);
+    s.concat(e).concat(r).forEach((a) => {
+      const o = t.scroll.query(a, h.ATTRIBUTE);
+      o instanceof i && (this.attributes[o.attrName] = o);
+    });
+  }
+  copy(t) {
+    Object.keys(this.attributes).forEach((s) => {
+      const e = this.attributes[s].value(this.domNode);
+      t.format(s, e);
+    });
+  }
+  move(t) {
+    this.copy(t), Object.keys(this.attributes).forEach((s) => {
+      this.attributes[s].remove(this.domNode);
+    }), this.attributes = {};
+  }
+  values() {
+    return Object.keys(this.attributes).reduce(
+      (t, s) => (t[s] = this.attributes[s].value(this.domNode), t),
+      {}
+    );
+  }
+}
+export {
+  y as default
+};

package/rich-text/lib/parchment/attributor/style.js

@@ -0,0 +1,24 @@
+/* 2025-11-03 10:27:46 */
+import a from "./attributor.js";
+function s(i) {
+  const t = i.split("-"), e = t.slice(1).map((r) => r[0].toUpperCase() + r.slice(1)).join("");
+  return t[0] + e;
+}
+class u extends a {
+  static keys(t) {
+    return (t.getAttribute("style") || "").split(";").map((e) => e.split(":")[0].trim());
+  }
+  add(t, e) {
+    return this.canAdd(t, e) ? (t.style[s(this.keyName)] = e, !0) : !1;
+  }
+  remove(t) {
+    t.style[s(this.keyName)] = "", t.getAttribute("style") || t.removeAttribute("style");
+  }
+  value(t) {
+    const e = t.style[s(this.keyName)];
+    return this.canAdd(t, e) ? e : "";
+  }
+}
+export {
+  u as default
+};

package/rich-text/lib/parchment/blot/abstract/container.js

@@ -0,0 +1,29 @@
+/* 2025-11-03 10:27:46 */
+import r from "../../scope.js";
+import o from "./parent.js";
+class c extends o {
+  static {
+    this.blotName = "container";
+  }
+  static {
+    this.scope = r.BLOCK_BLOT;
+  }
+  checkMerge() {
+    return this.next !== null && this.next.statics.blotName === this.statics.blotName;
+  }
+  deleteAt(e, t) {
+    super.deleteAt(e, t), this.enforceAllowedChildren();
+  }
+  formatAt(e, t, i, s) {
+    super.formatAt(e, t, i, s), this.enforceAllowedChildren();
+  }
+  insertAt(e, t, i) {
+    super.insertAt(e, t, i), this.enforceAllowedChildren();
+  }
+  optimize(e) {
+    super.optimize(e), this.children.length > 0 && this.next != null && this.checkMerge() && (this.next.moveChildren(this), this.next.remove());
+  }
+}
+export {
+  c as default
+};

package/rich-text/lib/parchment/blot/abstract/leaf.js

@@ -0,0 +1,44 @@
+/* 2025-11-03 10:27:46 */
+import i from "../../scope.js";
+import s from "./shadow.js";
+class m extends s {
+  static {
+    this.scope = i.INLINE_BLOT;
+  }
+  /**
+   * Returns the value represented by domNode if it is this Blot's type
+   * No checking that domNode can represent this Blot type is required so
+   * applications needing it should check externally before calling.
+   */
+  static value(t) {
+    return !0;
+  }
+  /**
+   * Given location represented by node and offset from DOM Selection Range,
+   * return index to that location.
+   */
+  index(t, e) {
+    return this.domNode === t || this.domNode.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_CONTAINED_BY ? Math.min(e, 1) : -1;
+  }
+  /**
+   * Given index to location within blot, return node and offset representing
+   * that location, consumable by DOM Selection Range
+   */
+  position(t, e) {
+    let o = Array.from(this.parent.domNode.childNodes).indexOf(this.domNode);
+    return t > 0 && (o += 1), [this.parent.domNode, o];
+  }
+  /**
+   * Return value represented by this blot
+   * Should not change without interaction from API or
+   * user change detectable by update()
+   */
+  value() {
+    return {
+      [this.statics.blotName]: this.statics.value(this.domNode) || !0
+    };
+  }
+}
+export {
+  m as default
+};

package/rich-text/lib/parchment/blot/abstract/parent.js

@@ -0,0 +1,176 @@
+/* 2025-11-03 10:27:46 */
+import "../../../../../dist/ui-common/utils/is.js";
+import c from "../../collection/linked-list.js";
+import u from "../../error.js";
+import f from "../../scope.js";
+import p from "./shadow.js";
+import { isString as N } from "@unicom-cloud/utils/is";
+function d(l, e) {
+  const t = e.find(l);
+  if (t) return t;
+  try {
+    return e.create(l);
+  } catch {
+    const r = e.create(f.INLINE);
+    return Array.from(l.childNodes).forEach((s) => {
+      r.domNode.appendChild(s);
+    }), l.parentNode && l.parentNode.replaceChild(r.domNode, l), r.attach(), r;
+  }
+}
+class h extends p {
+  constructor(e, t) {
+    super(e, t), this.uiNode = null, this.build();
+  }
+  static {
+    this.uiClass = "";
+  }
+  appendChild(e) {
+    this.insertBefore(e);
+  }
+  attach() {
+    super.attach(), this.children.forEach((e) => {
+      e.attach();
+    });
+  }
+  attachUI(e) {
+    this.uiNode != null && this.uiNode.remove(), this.uiNode = e, h.uiClass && this.uiNode.classList.add(h.uiClass), this.uiNode.setAttribute("contenteditable", "false"), this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);
+  }
+  /**
+   * Called during construction, should fill its own children LinkedList.
+   */
+  build() {
+    this.children = new c(), Array.from(this.domNode.childNodes).filter((e) => e !== this.uiNode).reverse().forEach((e) => {
+      try {
+        const t = d(e, this.scroll);
+        this.insertBefore(t, this.children.head || void 0);
+      } catch (t) {
+        if (t instanceof u)
+          return;
+        throw t;
+      }
+    });
+  }
+  deleteAt(e, t) {
+    if (e === 0 && t === this.length())
+      return this.remove();
+    this.children.forEachAt(e, t, (i, r, s) => {
+      i.deleteAt(r, s);
+    });
+  }
+  descendant(e, t = 0) {
+    const [i, r] = this.children.find(t);
+    return e.blotName == null && e(i) || e.blotName != null && i instanceof e ? [i, r] : i instanceof h ? i.descendant(e, r) : [null, -1];
+  }
+  descendants(e, t = 0, i = Number.MAX_VALUE) {
+    let r = [], s = i;
+    return this.children.forEachAt(
+      t,
+      i,
+      (n, o, a) => {
+        (e.blotName == null && e(n) || e.blotName != null && n instanceof e) && r.push(n), n instanceof h && (r = r.concat(
+          n.descendants(e, o, s)
+        )), s -= a;
+      }
+    ), r;
+  }
+  detach() {
+    this.children.forEach((e) => {
+      e.detach();
+    }), super.detach();
+  }
+  enforceAllowedChildren() {
+    let e = !1;
+    this.children.forEach((t) => {
+      e || this.statics.allowedChildren.some(
+        (r) => t instanceof r
+      ) || (t.statics.scope === f.BLOCK_BLOT ? (t.next != null && this.splitAfter(t), t.prev != null && this.splitAfter(t.prev), t.parent.unwrap(), e = !0) : t instanceof h ? t.unwrap() : t.remove());
+    });
+  }
+  formatAt(e, t, i, r) {
+    this.children.forEachAt(e, t, (s, n, o) => {
+      s.formatAt(n, o, i, r);
+    });
+  }
+  insertAt(e, t, i) {
+    const [r, s] = this.children.find(e);
+    if (r)
+      r.insertAt(s, t, i);
+    else {
+      const n = i == null ? this.scroll.create("text", t) : this.scroll.create(t, i);
+      this.appendChild(n);
+    }
+  }
+  insertBefore(e, t) {
+    e.parent != null && e.parent.children.remove(e);
+    let i = null;
+    this.children.insertBefore(e, t || null), e.parent = this, t != null && (i = t.domNode), (this.domNode.parentNode !== e.domNode || this.domNode.nextSibling !== i) && this.domNode.insertBefore(e.domNode, i), e.attach();
+  }
+  length() {
+    return this.children.reduce((e, t) => e + t.length(), 0);
+  }
+  moveChildren(e, t) {
+    this.children.forEach((i) => {
+      e.insertBefore(i, t);
+    });
+  }
+  optimize(e) {
+    if (super.optimize(e), this.enforceAllowedChildren(), this.uiNode != null && this.uiNode !== this.domNode.firstChild && this.domNode.insertBefore(this.uiNode, this.domNode.firstChild), this.children.length === 0)
+      if (this.statics.defaultChild != null) {
+        const t = this.scroll.create(this.statics.defaultChild.blotName);
+        this.appendChild(t);
+      } else
+        this.remove();
+  }
+  path(e, t = !1) {
+    const [i, r] = this.children.find(e, t), s = [[this, e]];
+    return i instanceof h ? s.concat(i.path(r, t)) : (i != null && s.push([i, r]), s);
+  }
+  removeChild(e) {
+    this.children.remove(e);
+  }
+  replaceWith(e, t) {
+    const i = N(e) ? this.scroll.create(e, t) : e;
+    return i instanceof h && this.moveChildren(i), super.replaceWith(i);
+  }
+  split(e, t = !1) {
+    if (!t) {
+      if (e === 0)
+        return this;
+      if (e === this.length())
+        return this.next;
+    }
+    const i = this.clone();
+    return this.parent && this.parent.insertBefore(i, this.next || void 0), this.children.forEachAt(e, this.length(), (r, s, n) => {
+      const o = r.split(s, t);
+      o != null && i.appendChild(o);
+    }), i;
+  }
+  splitAfter(e) {
+    const t = this.clone();
+    for (; e.next != null; )
+      t.appendChild(e.next);
+    return this.parent && this.parent.insertBefore(t, this.next || void 0), t;
+  }
+  unwrap() {
+    this.parent && this.moveChildren(this.parent, this.next || void 0), this.remove();
+  }
+  update(e, t) {
+    const i = [], r = [];
+    e.forEach((s) => {
+      s.target === this.domNode && s.type === "childList" && (i.push(...s.addedNodes), r.push(...s.removedNodes));
+    }), r.forEach((s) => {
+      if (s.parentNode != null && s.tagName !== "IFRAME" && document.body.compareDocumentPosition(s) & Node.DOCUMENT_POSITION_CONTAINED_BY)
+        return;
+      const n = this.scroll.find(s);
+      n != null && (n.domNode.parentNode == null || n.domNode.parentNode === this.domNode) && n.detach();
+    }), i.filter((s) => s.parentNode === this.domNode && s !== this.uiNode).sort((s, n) => s === n ? 0 : s.compareDocumentPosition(n) & Node.DOCUMENT_POSITION_FOLLOWING ? 1 : -1).forEach((s) => {
+      let n = null;
+      s.nextSibling != null && (n = this.scroll.find(s.nextSibling));
+      const o = d(s, this.scroll);
+      (o.next !== n || o.next == null) && (o.parent != null && o.parent.removeChild(this), this.insertBefore(o, n || void 0));
+    }), this.enforceAllowedChildren();
+  }
+}
+export {
+  h as default
+};

package/rich-text/lib/parchment/blot/abstract/shadow.js

@@ -0,0 +1,84 @@
+/* 2025-11-03 10:27:46 */
+import "../../../../../dist/ui-common/utils/is.js";
+import l from "../../error.js";
+import a from "../../registry.js";
+import h from "../../scope.js";
+import { isArray as p, isString as o, isNumber as c, isFunction as d } from "@unicom-cloud/utils/is";
+class w {
+  constructor(t, s) {
+    this.scroll = t, this.domNode = s, a.blots.set(s, this), this.prev = null, this.next = null;
+  }
+  static {
+    this.blotName = "abstract";
+  }
+  static create(t) {
+    if (this.tagName == null)
+      throw new l("Blot definition missing tagName");
+    let s, e;
+    return p(this.tagName) ? (o(t) ? (e = t.toUpperCase(), parseInt(e, 10).toString() === e && (e = parseInt(e, 10))) : c(t) && (e = t), c(e) ? s = document.createElement(this.tagName[e - 1]) : e && this.tagName.indexOf(e) > -1 ? s = document.createElement(e) : s = document.createElement(this.tagName[0])) : s = document.createElement(this.tagName), this.className && s.classList.add(this.className), s;
+  }
+  // Hack for accessing inherited static methods
+  get statics() {
+    return this.constructor;
+  }
+  attach() {
+  }
+  clone() {
+    const t = this.domNode.cloneNode(!1);
+    return this.scroll.create(t);
+  }
+  detach() {
+    this.parent != null && this.parent.removeChild(this), a.blots.delete(this.domNode);
+  }
+  deleteAt(t, s) {
+    this.isolate(t, s).remove();
+  }
+  formatAt(t, s, e, i) {
+    const r = this.isolate(t, s);
+    if (this.scroll.query(e, h.BLOT) != null && i)
+      r.wrap(e, i);
+    else if (this.scroll.query(e, h.ATTRIBUTE) != null) {
+      const n = this.scroll.create(this.statics.scope);
+      r.wrap(n), n.format(e, i);
+    }
+  }
+  insertAt(t, s, e) {
+    const i = e == null ? this.scroll.create("text", s) : this.scroll.create(s, e), r = this.split(t);
+    this.parent.insertBefore(i, r || void 0);
+  }
+  isolate(t, s) {
+    const e = this.split(t);
+    if (e == null)
+      throw new Error("Attempt to isolate at end");
+    return e.split(s), e;
+  }
+  length() {
+    return 1;
+  }
+  offset(t = this.parent) {
+    return this.parent == null || this === t ? 0 : this.parent.children.offset(this) + this.parent.offset(t);
+  }
+  optimize(t) {
+    this.statics.requiredContainer && !(this.parent instanceof this.statics.requiredContainer) && this.wrap(this.statics.requiredContainer.blotName);
+  }
+  remove() {
+    this.domNode.parentNode != null && this.domNode.parentNode.removeChild(this.domNode), this.detach();
+  }
+  replaceWith(t, s) {
+    const e = o(t) ? this.scroll.create(t, s) : t;
+    return this.parent != null && (this.parent.insertBefore(e, this.next || void 0), this.remove()), e;
+  }
+  split(t, s) {
+    return t === 0 ? this : this.next;
+  }
+  update(t, s) {
+  }
+  wrap(t, s) {
+    const e = o(t) ? this.scroll.create(t, s) : t;
+    if (this.parent != null && this.parent.insertBefore(e, this.next || void 0), !d(e.appendChild)) throw new l(`Cannot wrap ${t}`);
+    return e.appendChild(this), e;
+  }
+}
+export {
+  w as default
+};

package/rich-text/lib/parchment/blot/block.js

@@ -0,0 +1,77 @@
+/* 2025-11-03 10:27:46 */
+import "../../../../dist/ui-common/utils/is.js";
+import l from "../attributor/attributor.js";
+import c from "../attributor/store.js";
+import i from "../scope.js";
+import h from "./abstract/leaf.js";
+import m from "./abstract/parent.js";
+import f from "./inline.js";
+import { isString as u, isArray as n } from "@unicom-cloud/utils/is";
+class o extends m {
+  static {
+    this.blotName = "block";
+  }
+  static {
+    this.scope = i.BLOCK_BLOT;
+  }
+  static {
+    this.tagName = "P";
+  }
+  static {
+    this.allowedChildren = [
+      f,
+      o,
+      h
+    ];
+  }
+  static create(t) {
+    return super.create(t);
+  }
+  static formats(t, r) {
+    const s = r.query(o.blotName);
+    if (!(s != null && t.tagName === s.tagName)) {
+      if (u(this.tagName))
+        return !0;
+      if (n(this.tagName))
+        return t.tagName.toLowerCase();
+    }
+  }
+  constructor(t, r) {
+    super(t, r), this.attributes = new c(this.domNode);
+  }
+  format(t, r) {
+    const s = this.scroll.query(t, i.BLOCK);
+    s != null && (s instanceof l ? this.attributes.attribute(s, r) : t === this.statics.blotName && !r ? this.replaceWith(o.blotName) : r && (t !== this.statics.blotName || this.formats()[t] !== r) && this.replaceWith(t, r));
+  }
+  formats() {
+    const t = this.attributes.values(), r = this.statics.formats(this.domNode, this.scroll);
+    return r != null && (t[this.statics.blotName] = r), t;
+  }
+  formatAt(t, r, s, e) {
+    this.scroll.query(s, i.BLOCK) != null ? this.format(s, e) : super.formatAt(t, r, s, e);
+  }
+  insertAt(t, r, s) {
+    if (s == null || this.scroll.query(r, i.INLINE) != null)
+      super.insertAt(t, r, s);
+    else {
+      const e = this.split(t);
+      if (e != null) {
+        const a = this.scroll.create(r, s);
+        e.parent.insertBefore(a, e);
+      } else
+        throw new Error("Attempt to insertAt after block boundaries");
+    }
+  }
+  replaceWith(t, r) {
+    const s = super.replaceWith(t, r);
+    return this.attributes.copy(s), s;
+  }
+  update(t, r) {
+    super.update(t, r), t.some(
+      (e) => e.target === this.domNode && e.type === "attributes"
+    ) && this.attributes.build();
+  }
+}
+export {
+  o as default
+};

package/rich-text/lib/parchment/blot/embed.js

@@ -0,0 +1,18 @@
+/* 2025-11-03 10:27:46 */
+import a from "./abstract/leaf.js";
+class m extends a {
+  static formats(t, s) {
+  }
+  format(t, s) {
+    super.formatAt(0, this.length(), t, s);
+  }
+  formatAt(t, s, o, r) {
+    t === 0 && s === this.length() ? this.format(o, r) : super.formatAt(t, s, o, r);
+  }
+  formats() {
+    return this.statics.formats(this.domNode, this.scroll);
+  }
+}
+export {
+  m as default
+};

package/rich-text/lib/parchment/blot/inline.js

@@ -0,0 +1,80 @@
+/* 2025-11-03 10:27:46 */
+import "../../../../dist/ui-common/utils/is.js";
+import a from "../attributor/attributor.js";
+import f from "../attributor/store.js";
+import o from "../scope.js";
+import c from "./abstract/leaf.js";
+import h from "./abstract/parent.js";
+import { isString as m, isArray as u, isEqual as p } from "@unicom-cloud/utils/is";
+class e extends h {
+  static {
+    this.allowedChildren = [e, c];
+  }
+  static {
+    this.blotName = "inline";
+  }
+  static {
+    this.scope = o.INLINE_BLOT;
+  }
+  static {
+    this.tagName = "SPAN";
+  }
+  static create(r) {
+    return super.create(r);
+  }
+  static formats(r, s) {
+    const t = s.query(e.blotName);
+    if (!(t != null && r.tagName === t.tagName)) {
+      if (m(this.tagName))
+        return !0;
+      if (u(this.tagName))
+        return r.tagName.toLowerCase();
+    }
+  }
+  constructor(r, s) {
+    super(r, s), this.attributes = new f(this.domNode);
+  }
+  format(r, s) {
+    if (r === this.statics.blotName && !s)
+      this.children.forEach((t) => {
+        t instanceof e || (t = t.wrap(e.blotName, !0)), this.attributes.copy(t);
+      }), this.unwrap();
+    else {
+      const t = this.scroll.query(r, o.INLINE);
+      if (t == null)
+        return;
+      t instanceof a ? this.attributes.attribute(t, s) : s && (r !== this.statics.blotName || this.formats()[r] !== s) && this.replaceWith(r, s);
+    }
+  }
+  formats() {
+    const r = this.attributes.values(), s = this.statics.formats(this.domNode, this.scroll);
+    return s != null && (r[this.statics.blotName] = s), r;
+  }
+  formatAt(r, s, t, i) {
+    this.formats()[t] != null || this.scroll.query(t, o.ATTRIBUTE) ? this.isolate(r, s).format(t, i) : super.formatAt(r, s, t, i);
+  }
+  optimize(r) {
+    super.optimize(r);
+    const s = this.formats();
+    if (Object.keys(s).length === 0)
+      return this.unwrap();
+    const t = this.next;
+    t instanceof e && t.prev === this && p(s, t.formats()) && (t.moveChildren(this), t.remove());
+  }
+  replaceWith(r, s) {
+    const t = super.replaceWith(r, s);
+    return this.attributes.copy(t), t;
+  }
+  update(r, s) {
+    super.update(r, s), r.some(
+      (i) => i.target === this.domNode && i.type === "attributes"
+    ) && this.attributes.build();
+  }
+  wrap(r, s) {
+    const t = super.wrap(r, s);
+    return t instanceof e && this.attributes.move(t), t;
+  }
+}
+export {
+  e as default
+};