@unicom-cloud/ui 0.8.150 → 0.8.152

package/rich-text/lib/delta/index.js

@@ -1,315 +1,235 @@
-/* 2026-03-04 15:09:50 */
-import M from "lodash/cloneDeep";
-import { isArray as T, isString as w, isObjectLike as f, isNumber as c, isEqual as y } from "@unicom-cloud/ui-common/utils/is";
-import E from "../diff/index.js";
-import k from "./AttributeMap.js";
-import b from "./Op.js";
-import g from "./OpIterator.js";
-const A = "\0", N = (x, t) => {
-  if (!f(x)) throw new Error(`cannot retain a ${typeof x}`);
-  if (!f(t)) throw new Error(`cannot retain a ${typeof t}`);
-  const e = Object.keys(x)[0];
-  if (!e || e !== Object.keys(t)[0])
-    throw new Error(
-      `embed types not matched: ${e} != ${Object.keys(t)[0]}`
-    );
-  return [e, x[e], t[e]];
-};
-class u {
-  static {
-    this.Op = b;
-  }
-  static {
-    this.OpIterator = g;
-  }
-  static {
-    this.AttributeMap = k;
-  }
-  static {
-    this.handlers = {};
-  }
-  static registerEmbed(t, e) {
-    this.handlers[t] = e;
-  }
-  static unregisterEmbed(t) {
-    delete this.handlers[t];
-  }
-  static getHandler(t) {
-    const e = this.handlers[t];
-    if (!e)
-      throw new Error(`no handlers for embed type "${t}"`);
-    return e;
-  }
-  constructor(t) {
-    T(t) ? this.ops = t : t != null && T(t.ops) ? this.ops = t.ops : this.ops = [];
-  }
-  insert(t, e) {
-    const s = {};
-    return w(t) && t.length === 0 ? this : (s.insert = t, f(e) && Object.keys(e).length > 0 && (s.attributes = e), this.push(s));
-  }
-  delete(t) {
-    return t <= 0 ? this : this.push({ delete: t });
-  }
-  retain(t, e) {
-    if (c(t) && t <= 0)
-      return this;
-    const s = { retain: t };
-    return f(e) && Object.keys(e).length > 0 && (s.attributes = e), this.push(s);
-  }
-  push(t) {
-    let e = this.ops.length, s = this.ops[e - 1];
-    if (t = M(t), f(s)) {
-      if (c(t.delete) && c(s.delete))
-        return this.ops[e - 1] = { delete: s.delete + t.delete }, this;
-      if (c(s.delete) && t.insert != null && (e -= 1, s = this.ops[e - 1], !f(s)))
-        return this.ops.unshift(t), this;
-      if (y(t.attributes, s.attributes)) {
-        if (w(t.insert) && w(s.insert))
-          return this.ops[e - 1] = { insert: s.insert + t.insert }, f(t.attributes) && (this.ops[e - 1].attributes = t.attributes), this;
-        if (c(t.retain) && c(s.retain))
-          return this.ops[e - 1] = { retain: s.retain + t.retain }, f(t.attributes) && (this.ops[e - 1].attributes = t.attributes), this;
-      }
-    }
-    return e === this.ops.length ? this.ops.push(t) : this.ops.splice(e, 0, t), this;
-  }
-  chop() {
-    const t = this.ops[this.ops.length - 1];
-    return t && c(t.retain) && !t.attributes && this.ops.pop(), this;
-  }
-  filter(t) {
-    return this.ops.filter(t);
-  }
-  forEach(t) {
-    this.ops.forEach(t);
-  }
-  map(t) {
-    return this.ops.map(t);
-  }
-  partition(t) {
-    const e = [], s = [];
-    return this.forEach((n) => {
-      (t(n) ? e : s).push(n);
-    }), [e, s];
-  }
-  reduce(t, e) {
-    return this.ops.reduce(t, e);
-  }
-  changeLength() {
-    return this.reduce((t, e) => e.insert ? t + b.length(e) : e.delete ? t - e.delete : t, 0);
-  }
-  length() {
-    return this.reduce((t, e) => t + b.length(e), 0);
-  }
-  slice(t = 0, e = 1 / 0) {
-    const s = [], n = new g(this.ops);
-    let i = 0;
-    for (; i < e && n.hasNext(); ) {
-      let r;
-      i < t ? r = n.next(t - i) : (r = n.next(e - i), s.push(r)), i += b.length(r);
-    }
-    return new u(s);
-  }
-  compose(t) {
-    const e = new g(this.ops), s = new g(t.ops), n = [], i = s.peek();
-    if (i != null && c(i.retain) && i.attributes == null) {
-      let h = i.retain;
-      for (; e.peekType() === "insert" && e.peekLength() <= h; )
-        h -= e.peekLength(), n.push(e.next());
-      i.retain - h > 0 && s.next(i.retain - h);
-    }
-    const r = new u(n);
-    for (; e.hasNext() || s.hasNext(); )
-      if (s.peekType() === "insert")
-        r.push(s.next());
-      else if (e.peekType() === "delete")
-        r.push(e.next());
-      else {
-        const h = Math.min(e.peekLength(), s.peekLength()), a = e.next(h), l = s.next(h);
-        if (l.retain) {
-          const o = {};
-          if (c(a.retain))
-            o.retain = c(l.retain) ? h : l.retain;
-          else if (c(l.retain))
-            a.retain == null ? o.insert = a.insert : o.retain = a.retain;
-          else {
-            const p = a.retain == null ? "insert" : "retain", [m, L, O] = N(
-              a[p],
-              l.retain
-            ), j = u.getHandler(m);
-            o[p] = {
-              [m]: j.compose(
-                L,
-                O,
-                p === "retain"
-              )
-            };
-          }
-          const d = k.compose(
-            a.attributes,
-            l.attributes,
-            c(a.retain)
-          );
-          if (d && (o.attributes = d), r.push(o), !s.hasNext() && y(r.ops[r.ops.length - 1], o)) {
-            const p = new u(e.rest());
-            return r.concat(p).chop();
-          }
-        } else c(l.delete) && (c(a.retain) || f(a.retain)) && r.push(l);
-      }
-    return r.chop();
-  }
-  concat(t) {
-    const e = new u(this.ops.slice());
-    return t.ops.length > 0 && (e.push(t.ops[0]), e.ops = e.ops.concat(t.ops.slice(1))), e;
-  }
-  diff(t, e) {
-    if (this.ops === t.ops)
-      return new u();
-    const s = [this, t].map((a) => a.map((l) => {
-      if (l.insert != null)
-        return w(l.insert) ? l.insert : A;
-      const o = a === t ? "on" : "with";
-      throw new Error("diff() called " + o + " non-document");
-    }).join("")), n = new u(), i = E(s[0], s[1], e, !0), r = new g(this.ops), h = new g(t.ops);
-    return i.forEach((a) => {
-      let l = a[1].length;
-      for (; l > 0; ) {
-        let o = 0;
-        switch (a[0]) {
-          case E.INSERT:
-            o = Math.min(h.peekLength(), l), n.push(h.next(o));
-            break;
-          case E.DELETE:
-            o = Math.min(l, r.peekLength()), r.next(o), n.delete(o);
-            break;
-          case E.EQUAL: {
-            o = Math.min(
-              r.peekLength(),
-              h.peekLength(),
-              l
-            );
-            const d = r.next(o), p = h.next(o);
-            y(d.insert, p.insert) ? n.retain(
-              o,
-              k.diff(d.attributes, p.attributes)
-            ) : n.push(p).delete(o);
-            break;
-          }
-        }
-        l -= o;
-      }
-    }), n.chop();
-  }
-  eachLine(t, e = `
-`) {
-    const s = new g(this.ops);
-    let n = new u(), i = 0;
-    for (; s.hasNext(); ) {
-      if (s.peekType() !== "insert")
-        return;
-      const r = s.peek(), h = b.length(r) - s.peekLength(), a = w(r.insert) ? r.insert.indexOf(e, h) - h : -1;
-      if (a < 0)
-        n.push(s.next());
-      else if (a > 0)
-        n.push(s.next(a));
-      else {
-        if (t(n, s.next(1).attributes || {}, i) === !1)
-          return;
-        i += 1, n = new u();
-      }
-    }
-    n.length() > 0 && t(n, {}, i);
-  }
-  invert(t) {
-    const e = new u();
-    return this.reduce((s, n) => {
-      if (n.insert)
-        e.delete(b.length(n));
-      else {
-        if (c(n.retain) && n.attributes == null)
-          return e.retain(n.retain), s + n.retain;
-        if (n.delete || c(n.retain)) {
-          const i = n.delete || n.retain;
-          return t.slice(s, s + i).forEach((h) => {
-            n.delete ? e.push(h) : n.retain && n.attributes && e.retain(
-              b.length(h),
-              k.invert(n.attributes, h.attributes)
-            );
-          }), s + i;
-        } else if (f(n.retain)) {
-          const i = t.slice(s, s + 1), r = new g(i.ops).next(), [h, a, l] = N(
-            n.retain,
-            r.insert
-          ), o = u.getHandler(h);
-          return e.retain(
-            { [h]: o.invert(a, l) },
-            k.invert(n.attributes, r.attributes)
-          ), s + 1;
-        }
-      }
-      return s;
-    }, 0), e.chop();
-  }
-  transform(t, e = !1) {
-    if (e = !!e, c(t))
-      return this.transformPosition(t, e);
-    const s = t, n = new g(this.ops), i = new g(s.ops), r = new u();
-    for (; n.hasNext() || i.hasNext(); )
-      if (n.peekType() === "insert" && (e || i.peekType() !== "insert"))
-        r.retain(b.length(n.next()));
-      else if (i.peekType() === "insert")
-        r.push(i.next());
-      else {
-        const h = Math.min(n.peekLength(), i.peekLength()), a = n.next(h), l = i.next(h);
-        if (a.delete)
-          continue;
-        if (l.delete)
-          r.push(l);
-        else {
-          const o = a.retain, d = l.retain;
-          let p = f(d) ? d : h;
-          if (f(o) && f(d)) {
-            const m = Object.keys(o)[0];
-            if (m === Object.keys(d)[0]) {
-              const L = u.getHandler(m);
-              L && (p = {
-                [m]: L.transform(
-                  o[m],
-                  d[m],
-                  e
-                )
-              });
-            }
-          }
-          r.retain(
-            p,
-            k.transform(
-              a.attributes,
-              l.attributes,
-              e
-            )
-          );
-        }
-      }
-    return r.chop();
-  }
-  transformPosition(t, e = !1) {
-    e = !!e;
-    const s = new g(this.ops);
-    let n = 0;
-    for (; s.hasNext() && n <= t; ) {
-      const i = s.peekLength(), r = s.peekType();
-      if (s.next(), r === "delete") {
-        t -= Math.min(i, t - n);
-        continue;
-      } else r === "insert" && (n < t || !e) && (t += i);
-      n += i;
-    }
-    return t;
-  }
-}
-export {
-  k as AttributeMap,
-  b as Op,
-  g as OpIterator,
-  u as default
+/* 潘启宝 2026-03-24 16:29:04 星期二 */
+import { isArray as e, isEqual as t, isNumber as n, isObjectLike as r, isString as i } from "../../../utils/is.js";
+import a from "../diff/index.js";
+import o from "./AttributeMap.js";
+import s from "./Op.js";
+import c from "./OpIterator.js";
+import l from "lodash/cloneDeep";
+//#region components/pc/rich-text/lib/delta/index.ts
+var u = "\0", d = (e, t) => {
+	if (!r(e)) throw Error(`cannot retain a ${typeof e}`);
+	if (!r(t)) throw Error(`cannot retain a ${typeof t}`);
+	let n = Object.keys(e)[0];
+	if (!n || n !== Object.keys(t)[0]) throw Error(`embed types not matched: ${n} != ${Object.keys(t)[0]}`);
+	return [
+		n,
+		e[n],
+		t[n]
+	];
+}, f = class f {
+	static {
+		this.Op = s;
+	}
+	static {
+		this.OpIterator = c;
+	}
+	static {
+		this.AttributeMap = o;
+	}
+	static #e = {};
+	static registerEmbed(e, t) {
+		this.#e[e] = t;
+	}
+	static unregisterEmbed(e) {
+		delete this.#e[e];
+	}
+	static #t(e) {
+		let t = this.#e[e];
+		if (!t) throw Error(`no handlers for embed type "${e}"`);
+		return t;
+	}
+	constructor(t) {
+		e(t) ? this.ops = t : t != null && e(t.ops) ? this.ops = t.ops : this.ops = [];
+	}
+	insert(e, t) {
+		let n = {};
+		return i(e) && e.length === 0 ? this : (n.insert = e, r(t) && Object.keys(t).length > 0 && (n.attributes = t), this.push(n));
+	}
+	delete(e) {
+		return e <= 0 ? this : this.push({ delete: e });
+	}
+	retain(e, t) {
+		if (n(e) && e <= 0) return this;
+		let i = { retain: e };
+		return r(t) && Object.keys(t).length > 0 && (i.attributes = t), this.push(i);
+	}
+	push(e) {
+		let a = this.ops.length, o = this.ops[a - 1];
+		if (e = l(e), r(o)) {
+			if (n(e.delete) && n(o.delete)) return this.ops[a - 1] = { delete: o.delete + e.delete }, this;
+			if (n(o.delete) && e.insert != null && (--a, o = this.ops[a - 1], !r(o))) return this.ops.unshift(e), this;
+			if (t(e.attributes, o.attributes)) {
+				if (i(e.insert) && i(o.insert)) return this.ops[a - 1] = { insert: o.insert + e.insert }, r(e.attributes) && (this.ops[a - 1].attributes = e.attributes), this;
+				if (n(e.retain) && n(o.retain)) return this.ops[a - 1] = { retain: o.retain + e.retain }, r(e.attributes) && (this.ops[a - 1].attributes = e.attributes), this;
+			}
+		}
+		return a === this.ops.length ? this.ops.push(e) : this.ops.splice(a, 0, e), this;
+	}
+	chop() {
+		let e = this.ops[this.ops.length - 1];
+		return e && n(e.retain) && !e.attributes && this.ops.pop(), this;
+	}
+	filter(e) {
+		return this.ops.filter(e);
+	}
+	forEach(e) {
+		this.ops.forEach(e);
+	}
+	map(e) {
+		return this.ops.map(e);
+	}
+	partition(e) {
+		let t = [], n = [];
+		return this.forEach((r) => {
+			(e(r) ? t : n).push(r);
+		}), [t, n];
+	}
+	reduce(e, t) {
+		return this.ops.reduce(e, t);
+	}
+	changeLength() {
+		return this.reduce((e, t) => t.insert ? e + s.length(t) : t.delete ? e - t.delete : e, 0);
+	}
+	length() {
+		return this.reduce((e, t) => e + s.length(t), 0);
+	}
+	slice(e = 0, t = Infinity) {
+		let n = [], r = new c(this.ops), i = 0;
+		for (; i < t && r.hasNext();) {
+			let a;
+			i < e ? a = r.next(e - i) : (a = r.next(t - i), n.push(a)), i += s.length(a);
+		}
+		return new f(n);
+	}
+	compose(e) {
+		let i = new c(this.ops), a = new c(e.ops), s = [], l = a.peek();
+		if (l != null && n(l.retain) && l.attributes == null) {
+			let e = l.retain;
+			for (; i.peekType() === "insert" && i.peekLength() <= e;) e -= i.peekLength(), s.push(i.next());
+			l.retain - e > 0 && a.next(l.retain - e);
+		}
+		let u = new f(s);
+		for (; i.hasNext() || a.hasNext();) if (a.peekType() === "insert") u.push(a.next());
+		else if (i.peekType() === "delete") u.push(i.next());
+		else {
+			let e = Math.min(i.peekLength(), a.peekLength()), s = i.next(e), c = a.next(e);
+			if (c.retain) {
+				let r = {};
+				if (n(s.retain)) r.retain = n(c.retain) ? e : c.retain;
+				else if (n(c.retain)) s.retain == null ? r.insert = s.insert : r.retain = s.retain;
+				else {
+					let e = s.retain == null ? "insert" : "retain", [t, n, i] = d(s[e], c.retain), a = f.#t(t);
+					r[e] = { [t]: a.compose(n, i, e === "retain") };
+				}
+				let l = o.compose(s.attributes, c.attributes, n(s.retain));
+				if (l && (r.attributes = l), u.push(r), !a.hasNext() && t(u.ops[u.ops.length - 1], r)) {
+					let e = new f(i.rest());
+					return u.concat(e).chop();
+				}
+			} else n(c.delete) && (n(s.retain) || r(s.retain)) && u.push(c);
+		}
+		return u.chop();
+	}
+	concat(e) {
+		let t = new f(this.ops.slice());
+		return e.ops.length > 0 && (t.push(e.ops[0]), t.ops = t.ops.concat(e.ops.slice(1))), t;
+	}
+	diff(e, n) {
+		if (this.ops === e.ops) return new f();
+		let r = [this, e].map((t) => t.map((n) => {
+			if (n.insert != null) return i(n.insert) ? n.insert : u;
+			throw Error("diff() called " + (t === e ? "on" : "with") + " non-document");
+		}).join("")), s = new f(), l = a(r[0], r[1], n, !0), d = new c(this.ops), p = new c(e.ops);
+		return l.forEach((e) => {
+			let n = e[1].length;
+			for (; n > 0;) {
+				let r = 0;
+				switch (e[0]) {
+					case a.INSERT:
+						r = Math.min(p.peekLength(), n), s.push(p.next(r));
+						break;
+					case a.DELETE:
+						r = Math.min(n, d.peekLength()), d.next(r), s.delete(r);
+						break;
+					case a.EQUAL: {
+						r = Math.min(d.peekLength(), p.peekLength(), n);
+						let e = d.next(r), i = p.next(r);
+						t(e.insert, i.insert) ? s.retain(r, o.diff(e.attributes, i.attributes)) : s.push(i).delete(r);
+						break;
+					}
+				}
+				n -= r;
+			}
+		}), s.chop();
+	}
+	eachLine(e, t = "\n") {
+		let n = new c(this.ops), r = new f(), a = 0;
+		for (; n.hasNext();) {
+			if (n.peekType() !== "insert") return;
+			let o = n.peek(), c = s.length(o) - n.peekLength(), l = i(o.insert) ? o.insert.indexOf(t, c) - c : -1;
+			if (l < 0) r.push(n.next());
+			else if (l > 0) r.push(n.next(l));
+			else {
+				if (e(r, n.next(1).attributes || {}, a) === !1) return;
+				a += 1, r = new f();
+			}
+		}
+		r.length() > 0 && e(r, {}, a);
+	}
+	invert(e) {
+		let t = new f();
+		return this.reduce((i, a) => {
+			if (a.insert) t.delete(s.length(a));
+			else if (n(a.retain) && a.attributes == null) return t.retain(a.retain), i + a.retain;
+			else if (a.delete || n(a.retain)) {
+				let n = a.delete || a.retain;
+				return e.slice(i, i + n).forEach((e) => {
+					a.delete ? t.push(e) : a.retain && a.attributes && t.retain(s.length(e), o.invert(a.attributes, e.attributes));
+				}), i + n;
+			} else if (r(a.retain)) {
+				let n = new c(e.slice(i, i + 1).ops).next(), [r, s, l] = d(a.retain, n.insert), u = f.#t(r);
+				return t.retain({ [r]: u.invert(s, l) }, o.invert(a.attributes, n.attributes)), i + 1;
+			}
+			return i;
+		}, 0), t.chop();
+	}
+	transform(e, t = !1) {
+		if (t = !!t, n(e)) return this.transformPosition(e, t);
+		let i = e, a = new c(this.ops), l = new c(i.ops), u = new f();
+		for (; a.hasNext() || l.hasNext();) if (a.peekType() === "insert" && (t || l.peekType() !== "insert")) u.retain(s.length(a.next()));
+		else if (l.peekType() === "insert") u.push(l.next());
+		else {
+			let e = Math.min(a.peekLength(), l.peekLength()), n = a.next(e), i = l.next(e);
+			if (n.delete) continue;
+			if (i.delete) u.push(i);
+			else {
+				let a = n.retain, s = i.retain, c = r(s) ? s : e;
+				if (r(a) && r(s)) {
+					let e = Object.keys(a)[0];
+					if (e === Object.keys(s)[0]) {
+						let n = f.#t(e);
+						n && (c = { [e]: n.transform(a[e], s[e], t) });
+					}
+				}
+				u.retain(c, o.transform(n.attributes, i.attributes, t));
+			}
+		}
+		return u.chop();
+	}
+	transformPosition(e, t = !1) {
+		t = !!t;
+		let n = new c(this.ops), r = 0;
+		for (; n.hasNext() && r <= e;) {
+			let i = n.peekLength(), a = n.peekType();
+			if (n.next(), a === "delete") {
+				e -= Math.min(i, e - r);
+				continue;
+			} else a === "insert" && (r < e || !t) && (e += i);
+			r += i;
+		}
+		return e;
+	}
 };
+//#endregion
+export { f as default };
+/* 独立思考，明辨是非 */