@univerjs/core 0.6.7 → 0.6.9

package/lib/facade.js

@@ -0,0 +1,1428 @@
+var N = Object.defineProperty;
+var L = (n, e, t) => e in n ? N(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var d = (n, e, t) => L(n, typeof e != "symbol" ? e + "" : e, t);
+import { Disposable as V, Inject as l, Injector as _, AbsoluteRefType as F, UniverInstanceType as w, LifecycleStages as f, DataValidationType as W, DataValidationErrorStyle as q, DataValidationRenderMode as G, DataValidationOperator as J, DataValidationStatus as K, CommandType as Q, BaselineOffset as X, BooleanNumber as Y, HorizontalAlign as Z, TextDecoration as k, TextDirection as ee, VerticalAlign as te, WrapStrategy as re, BorderType as ne, BorderStyleTypes as ie, AutoFillSeries as oe, ColorType as se, CommonHideTypes as ce, CopyPasteType as ae, DeleteDirection as de, DeveloperMetadataVisibility as pe, Dimension as le, Direction as he, InterpolationPointType as ue, LocaleType as ye, MentionType as ge, ProtectionType as ve, RelativeDate as fe, SheetTypes as _e, ThemeColorType as me, LifecycleService as I, toDisposable as p, ICommandService as y, UndoCommand as h, IUndoRedoService as m, RedoCommand as u, Registry as Ee, UserManagerService as be, Rectangle as Se, numfmt as Ce, Tools as De, IUniverInstanceService as A, Univer as xe, CanceledError as D, ColorBuilder as Te, RichTextBuilder as we, RichTextValue as Re, ParagraphStyleBuilder as Oe, ParagraphStyleValue as Pe, TextStyleBuilder as je, TextStyleValue as Be, TextDecorationBuilder as He } from "@univerjs/core";
+import { filter as E } from "rxjs";
+class $ extends V {
+  /**
+   * @ignore
+   */
+  static extend(e) {
+    Object.getOwnPropertyNames(e.prototype).forEach((t) => {
+      t !== "constructor" && (this.prototype[t] = e.prototype[t]);
+    }), Object.getOwnPropertyNames(e).forEach((t) => {
+      t !== "prototype" && t !== "name" && t !== "length" && (this[t] = e[t]);
+    });
+  }
+}
+const x = Symbol("initializers");
+class Ue extends V {
+  constructor(e) {
+    super(), this._injector = e;
+    const t = this, r = Object.getPrototypeOf(this)[x];
+    r && r.forEach(function(i) {
+      i.apply(t, [e]);
+    });
+  }
+  /**
+   * @ignore
+   */
+  _initialize(e) {
+  }
+  /**
+   * @ignore
+   */
+  static extend(e) {
+    Object.getOwnPropertyNames(e.prototype).forEach((t) => {
+      if (t === "_initialize") {
+        let r = this.prototype[x];
+        r || (r = [], this.prototype[x] = r), r.push(e.prototype._initialize);
+      } else t !== "constructor" && (this.prototype[t] = e.prototype[t]);
+    }), Object.getOwnPropertyNames(e).forEach((t) => {
+      t !== "prototype" && t !== "name" && t !== "length" && (this[t] = e[t]);
+    });
+  }
+}
+var Ve = Object.getOwnPropertyDescriptor, Ie = (n, e, t, r) => {
+  for (var i = r > 1 ? void 0 : r ? Ve(e, t) : e, o = n.length - 1, s; o >= 0; o--)
+    (s = n[o]) && (i = s(i) || i);
+  return i;
+}, $e = (n, e) => (t, r) => e(t, r, n);
+let S = class extends $ {
+  constructor(n, e) {
+    super(), this._blob = n, this._injector = e;
+  }
+  /**
+   * Returns a copy of this blob.
+   * @returns a new blob by copying the current blob
+   * @example
+   * ```ts
+   * const blob = univerAPI.newBlob();
+   * const newBlob = blob.copyBlob();
+   * console.log(newBlob);
+   * ```
+   */
+  copyBlob() {
+    return this._injector.createInstance(S, this._blob);
+  }
+  /**
+   * Return the data inside this object as a blob converted to the specified content type.
+   * @param contentType the content type refer to https://developer.mozilla.org/en-US/docs/Web/HTTP/MIME_types/Common_types
+   * @returns a new blob by converting the current blob to the specified content type
+   * @example
+   * ```ts
+   * const blob = univerAPI.newBlob();
+   * const newBlob = blob.getAs('text/plain');
+   * console.log(newBlob);
+   * ```
+   */
+  getAs(n) {
+    const e = this.copyBlob();
+    return e.setContentType(n), e;
+  }
+  getDataAsString(n) {
+    return this._blob === null ? Promise.resolve("") : n === void 0 ? this._blob.text() : new Promise((e, t) => {
+      this._blob.arrayBuffer().then((r) => {
+        const i = new TextDecoder(n).decode(r);
+        e(i);
+      }).catch((r) => {
+        t(new Error(`Failed to read Blob as ArrayBuffer: ${r.message}`));
+      });
+    });
+  }
+  /**
+   * Gets the data stored in this blob.
+   * @returns the blob content as a byte array
+   * @example
+   * ```ts
+   * const blob = univerAPI.newBlob();
+   * const bytes = await blob.getBytes();
+   * console.log(bytes);
+   * ```
+   */
+  getBytes() {
+    return this._blob ? this._blob.arrayBuffer().then((n) => new Uint8Array(n)) : Promise.reject(new Error("Blob is undefined or null."));
+  }
+  /**
+   * Sets the data stored in this blob.
+   * @param bytes a byte array
+   * @returns the blob object
+   * @example
+   * ```ts
+   * const blob = univerAPI.newBlob();
+   * const bytes = new Uint8Array(10);
+   * blob.setBytes(bytes);
+   * ```
+   */
+  setBytes(n) {
+    return this._blob = new Blob([n]), this;
+  }
+  setDataFromString(n, e) {
+    const t = e != null ? e : "text/plain", r = new Blob([n], { type: t });
+    return this._blob = r, this;
+  }
+  /**
+   * Gets the content type of the data stored in this blob.
+   * @returns the content type
+   * @example
+   * ```ts
+   * const blob = univerAPI.newBlob();
+   * const contentType = blob.getContentType();
+   * console.log(contentType);
+   * ```
+   */
+  getContentType() {
+    var n;
+    return (n = this._blob) == null ? void 0 : n.type;
+  }
+  /**
+   * Sets the content type of the data stored in this blob.
+   * @param contentType the content type refer to https://developer.mozilla.org/en-US/docs/Web/HTTP/MIME_types/Common_types
+   * @returns the blob object
+   * @example
+   * ```ts
+   * const blob = univerAPI.newBlob();
+   * blob.setContentType('text/plain');
+   * ```
+   */
+  setContentType(n) {
+    var e;
+    return this._blob = (e = this._blob) == null ? void 0 : e.slice(0, this._blob.size, n), this;
+  }
+};
+S = Ie([
+  $e(1, l(_))
+], S);
+const g = class g {
+  static get() {
+    if (this._instance)
+      return this._instance;
+    const e = new g();
+    return this._instance = e, e;
+  }
+  /**
+   * @ignore
+   */
+  static extend(e) {
+    Object.getOwnPropertyNames(e.prototype).forEach((t) => {
+      t !== "constructor" && (this.prototype[t] = e.prototype[t]);
+    }), Object.getOwnPropertyNames(e).forEach((t) => {
+      t !== "prototype" && t !== "name" && t !== "length" && (this[t] = e[t]);
+    });
+  }
+  constructor() {
+    for (const e in g.prototype)
+      this[e] = g.prototype[e];
+  }
+  /**
+   * Defines different types of absolute references
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.AbsoluteRefType);
+   * ```
+   */
+  get AbsoluteRefType() {
+    return F;
+  }
+  /**
+   * Defines different types of Univer instances
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.UniverInstanceType.UNIVER_SHEET);
+   * ```
+   */
+  get UniverInstanceType() {
+    return w;
+  }
+  /**
+   * Represents different stages in the lifecycle
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.LifecycleStages.Rendered);
+   * ```
+   */
+  get LifecycleStages() {
+    return f;
+  }
+  /**
+   * Different types of data validation
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.DataValidationType.LIST);
+   * ```
+   */
+  get DataValidationType() {
+    return W;
+  }
+  /**
+   * Different error display styles
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.DataValidationErrorStyle.WARNING);
+   * ```
+   */
+  get DataValidationErrorStyle() {
+    return q;
+  }
+  /**
+   * Different validation rendering modes
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.DataValidationRenderMode.TEXT);
+   * ```
+   */
+  get DataValidationRenderMode() {
+    return G;
+  }
+  /**
+   * Different validation operators
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.DataValidationOperator.BETWEEN);
+   * ```
+   */
+  get DataValidationOperator() {
+    return J;
+  }
+  /**
+   * Different validation states
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.DataValidationStatus.VALID);
+   * ```
+   */
+  get DataValidationStatus() {
+    return K;
+  }
+  /**
+   * Different types of commands
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.CommandType.COMMAND);
+   * ```
+   */
+  get CommandType() {
+    return Q;
+  }
+  /**
+   * Different baseline offsets for text baseline positioning
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.BaselineOffset.SUPERSCRIPT);
+   * ```
+   */
+  get BaselineOffset() {
+    return X;
+  }
+  /**
+   * Boolean number representations
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.BooleanNumber.TRUE);
+   * ```
+   */
+  get BooleanNumber() {
+    return Y;
+  }
+  /**
+   * Different horizontal text alignment options
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.HorizontalAlign.CENTER);
+   * ```
+   */
+  get HorizontalAlign() {
+    return Z;
+  }
+  /**
+   * Different text decoration styles
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.TextDecoration.DOUBLE);
+   * ```
+   */
+  get TextDecoration() {
+    return k;
+  }
+  /**
+   * Different text direction options
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.TextDirection.LEFT_TO_RIGHT);
+   * ```
+   */
+  get TextDirection() {
+    return ee;
+  }
+  /**
+   * Different vertical text alignment options
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.VerticalAlign.MIDDLE);
+   * ```
+   */
+  get VerticalAlign() {
+    return te;
+  }
+  /**
+   * Different wrap strategy options
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.WrapStrategy.WRAP);
+   * ```
+   */
+  get WrapStrategy() {
+    return re;
+  }
+  /**
+   * Different border types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.BorderType.OUTSIDE);
+   * ```
+   */
+  get BorderType() {
+    return ne;
+  }
+  /**
+   * Different border style types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.BorderStyleTypes.NONE);
+   * ```
+   */
+  get BorderStyleTypes() {
+    return ie;
+  }
+  /**
+   * Auto fill series types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.AutoFillSeries.ALTERNATE_SERIES);
+   * ```
+   */
+  get AutoFillSeries() {
+    return oe;
+  }
+  /**
+   * Color types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.ColorType.RGB);
+   * ```
+   */
+  get ColorType() {
+    return se;
+  }
+  /**
+   * Common hide types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.CommonHideTypes.ON);
+   * ```
+   */
+  get CommonHideTypes() {
+    return ce;
+  }
+  /**
+   * Copy paste types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.CopyPasteType.PASTE_VALUES);
+   * ```
+   */
+  get CopyPasteType() {
+    return ae;
+  }
+  /**
+   * Delete direction types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.DeleteDirection.LEFT);
+   * ```
+   */
+  get DeleteDirection() {
+    return de;
+  }
+  /**
+   * Developer metadata visibility types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.DeveloperMetadataVisibility.DOCUMENT);
+   * ```
+   */
+  get DeveloperMetadataVisibility() {
+    return pe;
+  }
+  /**
+   * Dimension types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.Dimension.ROWS);
+   * ```
+   */
+  get Dimension() {
+    return le;
+  }
+  /**
+   * Direction types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.Direction.UP);
+   * ```
+   */
+  get Direction() {
+    return he;
+  }
+  /**
+   * Interpolation point types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.InterpolationPointType.NUMBER);
+   * ```
+   */
+  get InterpolationPointType() {
+    return ue;
+  }
+  /**
+   * Locale types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.LocaleType.EN_US);
+   * ```
+   */
+  get LocaleType() {
+    return ye;
+  }
+  /**
+   * Mention types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.MentionType.PERSON);
+   * ```
+   */
+  get MentionType() {
+    return ge;
+  }
+  /**
+   * Protection types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.ProtectionType.RANGE);
+   * ```
+   */
+  get ProtectionType() {
+    return ve;
+  }
+  /**
+   * Relative date types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.RelativeDate.TODAY);
+   * ```
+   */
+  get RelativeDate() {
+    return fe;
+  }
+  /**
+   * Sheet types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.SheetTypes.GRID);
+   * ```
+   */
+  get SheetTypes() {
+    return _e;
+  }
+  /**
+   * Theme color types
+   *
+   * @example
+   * ```ts
+   * console.log(univerAPI.Enum.ThemeColorType.ACCENT1);
+   * ```
+   */
+  get ThemeColorType() {
+    return me;
+  }
+};
+/**
+ * @ignore
+ */
+d(g, "_instance");
+let R = g;
+const v = class v {
+  static get() {
+    if (this._instance)
+      return this._instance;
+    const e = new v();
+    return this._instance = e, e;
+  }
+  /**
+   * @ignore
+   */
+  static extend(e) {
+    Object.getOwnPropertyNames(e.prototype).forEach((t) => {
+      t !== "constructor" && (this.prototype[t] = e.prototype[t]);
+    }), Object.getOwnPropertyNames(e).forEach((t) => {
+      t !== "prototype" && t !== "name" && t !== "length" && (this[t] = e[t]);
+    });
+  }
+  constructor() {
+    for (const e in v.prototype)
+      this[e] = v.prototype[e];
+  }
+  /**
+   * Event fired when a document is created
+   * @see {@link IDocCreatedParam}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.DocCreated, (params) => {
+   *   const { unitId, type, doc, unit } = params;
+   *   console.log('doc created', params);
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get DocCreated() {
+    return "DocCreated";
+  }
+  /**
+   * Event fired when a document is disposed
+   * @see {@link IDocDisposedEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.DocDisposed, (params) => {
+   *   const { unitId, unitType, snapshot } = params;
+   *   console.log('doc disposed', params);
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get DocDisposed() {
+    return "DocDisposed";
+  }
+  /**
+   * Event fired when life cycle is changed
+   * @see {@link ILifeCycleChangedEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.LifeCycleChanged, (params) => {
+   *   const { stage } = params;
+   *   console.log('life cycle changed', params);
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get LifeCycleChanged() {
+    return "LifeCycleChanged";
+  }
+  /**
+   * Event fired when a redo command is executed
+   * @see {@link ICommandEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.Redo, (event) => {
+   *   const { params, id, type } = event;
+   *   console.log('redo command executed', event);
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get Redo() {
+    return "Redo";
+  }
+  /**
+   * Event fired when an undo command is executed
+   * @see {@link ICommandEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.Undo, (event) => {
+   *   const { params, id, type } = event;
+   *   console.log('undo command executed', event);
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get Undo() {
+    return "Undo";
+  }
+  /**
+   * Event fired before a redo command is executed
+   * @see {@link ICommandEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.BeforeRedo, (event) => {
+   *   const { params, id, type } = event;
+   *   console.log('before redo command executed', event);
+   *
+   *   // Cancel the redo operation
+   *   event.cancel = true;
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get BeforeRedo() {
+    return "BeforeRedo";
+  }
+  /**
+   * Event fired before an undo command is executed
+   * @see {@link ICommandEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.BeforeUndo, (event) => {
+   *   const { params, id, type } = event;
+   *   console.log('before undo command executed', event);
+   *
+   *   // Cancel the undo operation
+   *   event.cancel = true;
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get BeforeUndo() {
+    return "BeforeUndo";
+  }
+  /**
+   * Event fired when a command is executed
+   * @see {@link ICommandEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.CommandExecuted, (event) => {
+   *   const { params, id, type } = event;
+   *   console.log('command executed', event);
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get CommandExecuted() {
+    return "CommandExecuted";
+  }
+  /**
+   * Event fired before a command is executed
+   * @see {@link ICommandEvent}
+   * @example
+   * ```ts
+   * const disposable = univerAPI.addEvent(univerAPI.Event.BeforeCommandExecute, (event) => {
+   *   const { params, id, type } = event;
+   *   console.log('before command executed', event);
+   *
+   *   // Cancel the command execution
+   *   event.cancel = true;
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  get BeforeCommandExecute() {
+    return "BeforeCommandExecute";
+  }
+};
+/**
+ * @ignore
+ */
+d(v, "_instance");
+let O = v;
+var Me = Object.getOwnPropertyDescriptor, ze = (n, e, t, r) => {
+  for (var i = r > 1 ? void 0 : r ? Me(e, t) : e, o = n.length - 1, s; o >= 0; o--)
+    (s = n[o]) && (i = s(i) || i);
+  return i;
+}, M = (n, e) => (t, r) => e(t, r, n);
+let P = class extends $ {
+  constructor(n, e) {
+    super(), this._injector = n, this._lifecycleService = e;
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.LifeCycleChanged, ({ stage }) => {})` as instead
+   */
+  onStarting(n) {
+    return p(this._lifecycleService.lifecycle$.pipe(E((e) => e === f.Starting)).subscribe(n));
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.LifeCycleChanged, ({ stage }) => {})` as instead
+   */
+  onReady(n) {
+    return p(this._lifecycleService.lifecycle$.pipe(E((e) => e === f.Ready)).subscribe(n));
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.LifeCycleChanged, ({ stage }) => {})` as instead
+   */
+  onRendered(n) {
+    return p(this._lifecycleService.lifecycle$.pipe(E((e) => e === f.Rendered)).subscribe(n));
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.LifeCycleChanged, ({ stage }) => {})` as instead
+   */
+  onSteady(n) {
+    return p(this._lifecycleService.lifecycle$.pipe(E((e) => e === f.Steady)).subscribe(n));
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.BeforeUndo, (event) => {})` as instead
+   */
+  onBeforeUndo(n) {
+    return this._injector.get(y).beforeCommandExecuted((t) => {
+      if (t.id === h.id) {
+        const i = this._injector.get(m).pitchTopUndoElement();
+        i && n(i);
+      }
+    });
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.Undo, (event) => {})` as instead
+   */
+  onUndo(n) {
+    return this._injector.get(y).onCommandExecuted((t) => {
+      if (t.id === h.id) {
+        const i = this._injector.get(m).pitchTopUndoElement();
+        i && n(i);
+      }
+    });
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.BeforeRedo, (event) => {})` as instead
+   */
+  onBeforeRedo(n) {
+    return this._injector.get(y).beforeCommandExecuted((t) => {
+      if (t.id === u.id) {
+        const i = this._injector.get(m).pitchTopRedoElement();
+        i && n(i);
+      }
+    });
+  }
+  /**
+   * @param callback
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.Redo, (event) => {})` as instead
+   */
+  onRedo(n) {
+    return this._injector.get(y).onCommandExecuted((t) => {
+      if (t.id === u.id) {
+        const i = this._injector.get(m).pitchTopRedoElement();
+        i && n(i);
+      }
+    });
+  }
+};
+P = ze([
+  M(0, l(_)),
+  M(1, l(I))
+], P);
+var Ae = Object.getOwnPropertyDescriptor, Ne = (n, e, t, r) => {
+  for (var i = r > 1 ? void 0 : r ? Ae(e, t) : e, o = n.length - 1, s; o >= 0; o--)
+    (s = n[o]) && (i = s(i) || i);
+  return i;
+}, Le = (n, e) => (t, r) => e(t, r, n);
+let j = class extends Ue {
+  constructor(n, e) {
+    super(e), this.doc = n;
+  }
+};
+j = Ne([
+  Le(1, l(_))
+], j);
+class Fe {
+  constructor() {
+    d(this, "_eventRegistry", /* @__PURE__ */ new Map());
+    d(this, "_eventHandlerMap", /* @__PURE__ */ new Map());
+    d(this, "_eventHandlerRegisted", /* @__PURE__ */ new Map());
+  }
+  _ensureEventRegistry(e) {
+    return this._eventRegistry.has(e) || this._eventRegistry.set(e, new Ee()), this._eventRegistry.get(e);
+  }
+  registerEventHandler(e, t) {
+    const r = this._eventHandlerMap.get(e);
+    return r ? r.add(t) : this._eventHandlerMap.set(e, /* @__PURE__ */ new Set([t])), this._ensureEventRegistry(e).getData().length && this._initEventHandler(e), p(() => {
+      var i, o, s, a;
+      (i = this._eventHandlerMap.get(e)) == null || i.delete(t), (s = (o = this._eventHandlerRegisted.get(e)) == null ? void 0 : o.get(t)) == null || s.dispose(), (a = this._eventHandlerRegisted.get(e)) == null || a.delete(t);
+    });
+  }
+  removeEvent(e, t) {
+    const r = this._ensureEventRegistry(e);
+    if (r.delete(t), r.getData().length === 0) {
+      const i = this._eventHandlerRegisted.get(e);
+      i == null || i.forEach((o) => o.dispose()), this._eventHandlerRegisted.delete(e);
+    }
+  }
+  _initEventHandler(e) {
+    let t = this._eventHandlerRegisted.get(e);
+    const r = this._eventHandlerMap.get(e);
+    r && (t || (t = /* @__PURE__ */ new Map(), this._eventHandlerRegisted.set(e, t), r == null || r.forEach((i) => {
+      t == null || t.set(i, p(i()));
+    })));
+  }
+  /**
+   * Add an event listener
+   * @param {string} event key of event
+   * @param {(params: IEventParamConfig[typeof event]) => void} callback callback when event triggered
+   * @returns {Disposable} The Disposable instance, for remove the listener
+   * @example
+   * ```ts
+   * univerAPI.addEvent(univerAPI.Event.LifeCycleChanged, (params) => {
+   *   const { stage } = params;
+   *   console.log('life cycle changed', params);
+   * });
+   * ```
+   */
+  addEvent(e, t) {
+    return this._ensureEventRegistry(e).add(t), this._initEventHandler(e), p(() => this.removeEvent(e, t));
+  }
+  /**
+   * Fire an event, used in internal only.
+   * @param {string} event key of event
+   * @param {any} params params of event
+   * @returns {boolean} should cancel
+   * @example
+   * ```ts
+   * this.fireEvent(univerAPI.Event.LifeCycleChanged, params);
+   * ```
+   */
+  fireEvent(e, t) {
+    var r;
+    return (r = this._eventRegistry.get(e)) == null || r.getData().forEach((i) => {
+      i(t);
+    }), t.cancel;
+  }
+}
+var We = Object.getOwnPropertyDescriptor, qe = (n, e, t, r) => {
+  for (var i = r > 1 ? void 0 : r ? We(e, t) : e, o = n.length - 1, s; o >= 0; o--)
+    (s = n[o]) && (i = s(i) || i);
+  return i;
+}, z = (n, e) => (t, r) => e(t, r, n);
+let B = class extends $ {
+  constructor(n, e) {
+    super(), this._injector = n, this._userManagerService = e;
+  }
+  /**
+   * Get current user info.
+   * @returns {IUser} Current user info.
+   * @example
+   * ```typescript
+   * univerAPI.getUserManager().getCurrentUser();
+   * ```
+   */
+  getCurrentUser() {
+    return this._userManagerService.getCurrentUser();
+  }
+};
+B = qe([
+  z(0, l(_)),
+  z(1, l(be))
+], B);
+const C = class C {
+  static get() {
+    if (this._instance)
+      return this._instance;
+    const e = new C();
+    return this._instance = e, e;
+  }
+  /**
+   * @ignore
+   */
+  static extend(e) {
+    Object.getOwnPropertyNames(e.prototype).forEach((t) => {
+      t !== "constructor" && (this.prototype[t] = e.prototype[t]);
+    }), Object.getOwnPropertyNames(e).forEach((t) => {
+      t !== "prototype" && t !== "name" && t !== "length" && (this[t] = e[t]);
+    });
+  }
+  /**
+   * Rectangle utils, including range operations likes merge, subtract, split
+   *
+   * @example
+   * ```ts
+   * const ranges = [
+   *   { startRow: 0, startColumn: 0, endRow: 1, endColumn: 1 },
+   *   { startRow: 1, startColumn: 1, endRow: 2, endColumn: 2 }
+   * ];
+   * const merged = univerAPI.Util.rectangle.mergeRanges(ranges);
+   * console.log(merged);
+   * ```
+   */
+  get rectangle() {
+    return Se;
+  }
+  /**
+   * Number format utils, including parse and strigify about date, price, etc
+   *
+   * @example
+   * ```ts
+   * const text = univerAPI.Util.numfmt.format('#,##0.00', 1234.567);
+   * console.log(text);
+   * ```
+   */
+  get numfmt() {
+    return Ce;
+  }
+  /**
+   * common tools
+   *
+   * @example
+   * ```ts
+   * const key = univerAPI.Util.tools.generateRandomId(6);
+   * console.log(key);
+   * ```
+   */
+  get tools() {
+    return De;
+  }
+};
+/**
+ * @ignore
+ */
+d(C, "_instance");
+let H = C;
+var Ge = Object.getOwnPropertyDescriptor, Je = (n, e, t, r) => {
+  for (var i = r > 1 ? void 0 : r ? Ge(e, t) : e, o = n.length - 1, s; o >= 0; o--)
+    (s = n[o]) && (i = s(i) || i);
+  return i;
+}, b = (n, e) => (t, r) => e(t, r, n);
+const T = Symbol("initializers");
+let U = class extends V {
+  constructor(e, t, r, i) {
+    super();
+    d(this, "_eventRegistry", new Fe());
+    d(this, "registerEventHandler", (e, t) => this._eventRegistry.registerEventHandler(e, t));
+    this._injector = e, this._commandService = t, this._univerInstanceService = r, this._lifecycleService = i, this.registerEventHandler(
+      this.Event.LifeCycleChanged,
+      () => p(
+        this._lifecycleService.lifecycle$.subscribe((s) => {
+          this.fireEvent(this.Event.LifeCycleChanged, { stage: s });
+        })
+      )
+    ), this._initUnitEvent(this._injector), this._initBeforeCommandEvent(this._injector), this._initCommandEvent(this._injector), this._injector.onDispose(() => {
+      this.dispose();
+    });
+    const o = Object.getPrototypeOf(this)[T];
+    if (o) {
+      const s = this;
+      o.forEach(function(a) {
+        a.apply(s, [e]);
+      });
+    }
+  }
+  /**
+   * Create an FUniver instance, if the injector is not provided, it will create a new Univer instance.
+   * @static
+   * @param {Univer | Injector} wrapped - The Univer instance or injector instance.
+   * @returns {FUniver} - The FUniver instance.
+   *
+   * @example
+   * ```ts
+   * const univerAPI = FUniver.newAPI(univer);
+   * ```
+   */
+  static newAPI(e) {
+    return (e instanceof xe ? e.__getInjector() : e).createInstance(U);
+  }
+  /**
+   * @ignore
+   */
+  _initialize(e) {
+  }
+  /**
+   * @ignore
+   */
+  static extend(e) {
+    Object.getOwnPropertyNames(e.prototype).forEach((t) => {
+      if (t === "_initialize") {
+        let r = this.prototype[T];
+        r || (r = [], this.prototype[T] = r), r.push(e.prototype._initialize);
+      } else t !== "constructor" && (this.prototype[t] = e.prototype[t]);
+    }), Object.getOwnPropertyNames(e).forEach((t) => {
+      t !== "prototype" && t !== "name" && t !== "length" && (this[t] = e[t]);
+    });
+  }
+  _initCommandEvent(e) {
+    const t = e.get(y);
+    this.registerEventHandler(
+      this.Event.Redo,
+      () => t.onCommandExecuted((r) => {
+        const { id: i, type: o, params: s } = r;
+        if (r.id === u.id) {
+          const c = { id: i, type: o, params: s };
+          this.fireEvent(this.Event.Redo, c);
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.Undo,
+      () => t.onCommandExecuted((r) => {
+        const { id: i, type: o, params: s } = r;
+        if (r.id === h.id) {
+          const c = { id: i, type: o, params: s };
+          this.fireEvent(this.Event.Undo, c);
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.CommandExecuted,
+      () => t.onCommandExecuted((r) => {
+        const { id: i, type: o, params: s } = r;
+        if (r.id !== u.id && r.id !== h.id) {
+          const c = { id: i, type: o, params: s };
+          this.fireEvent(this.Event.CommandExecuted, c);
+        }
+      })
+    );
+  }
+  _initBeforeCommandEvent(e) {
+    const t = e.get(y);
+    this.registerEventHandler(
+      this.Event.BeforeRedo,
+      () => t.beforeCommandExecuted((r) => {
+        const { id: i, type: o, params: s } = r;
+        if (r.id === u.id) {
+          const c = { id: i, type: o, params: s };
+          if (this.fireEvent(this.Event.BeforeRedo, c), c.cancel)
+            throw new D();
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.BeforeUndo,
+      () => t.beforeCommandExecuted((r) => {
+        const { id: i, type: o, params: s } = r;
+        if (r.id === h.id) {
+          const c = { id: i, type: o, params: s };
+          if (this.fireEvent(this.Event.BeforeUndo, c), c.cancel)
+            throw new D();
+        }
+      })
+    ), this.registerEventHandler(
+      this.Event.BeforeCommandExecute,
+      () => t.beforeCommandExecuted((r) => {
+        const { id: i, type: o, params: s } = r;
+        if (r.id !== u.id && r.id !== h.id) {
+          const c = { id: i, type: o, params: s };
+          if (this.fireEvent(this.Event.BeforeCommandExecute, c), c.cancel)
+            throw new D();
+        }
+      })
+    );
+  }
+  _initUnitEvent(e) {
+    const t = e.get(A);
+    this.registerEventHandler(
+      this.Event.DocDisposed,
+      () => t.unitDisposed$.subscribe((r) => {
+        r.type === w.UNIVER_DOC && this.fireEvent(this.Event.DocDisposed, {
+          unitId: r.getUnitId(),
+          unitType: r.type,
+          snapshot: r.getSnapshot()
+        });
+      })
+    ), this.registerEventHandler(
+      this.Event.DocCreated,
+      () => t.unitAdded$.subscribe((r) => {
+        if (r.type === w.UNIVER_DOC) {
+          const i = r, o = e.createInstance(j, i);
+          this.fireEvent(this.Event.DocCreated, {
+            unitId: r.getUnitId(),
+            type: r.type,
+            doc: o,
+            unit: o
+          });
+        }
+      })
+    );
+  }
+  /**
+   * Dispose the UniverSheet by the `unitId`. The UniverSheet would be unload from the application.
+   * @param unitId The unit id of the UniverSheet.
+   * @returns Whether the Univer instance is disposed successfully.
+   *
+   * @example
+   * ```ts
+   * const fWorkbook = univerAPI.getActiveWorkbook();
+   * const unitId = fWorkbook?.getId();
+   *
+   * if (unitId) {
+   *   univerAPI.disposeUnit(unitId);
+   * }
+   * ```
+   */
+  disposeUnit(e) {
+    return this._univerInstanceService.disposeUnit(e);
+  }
+  /**
+   * Get the current lifecycle stage.
+   * @returns {LifecycleStages} - The current lifecycle stage.
+   *
+   * @example
+   * ```ts
+   * const stage = univerAPI.getCurrentLifecycleStage();
+   * console.log(stage);
+   * ```
+   */
+  getCurrentLifecycleStage() {
+    return this._injector.get(I).stage;
+  }
+  /**
+   * Undo an editing on the currently focused document.
+   * @returns {Promise<boolean>} undo result
+   *
+   * @example
+   * ```ts
+   * await univerAPI.undo();
+   * ```
+   */
+  undo() {
+    return this._commandService.executeCommand(h.id);
+  }
+  /**
+   * Redo an editing on the currently focused document.
+   * @returns {Promise<boolean>} redo result
+   *
+   * @example
+   * ```ts
+   * await univerAPI.redo();
+   * ```
+   */
+  redo() {
+    return this._commandService.executeCommand(u.id);
+  }
+  /**
+   * Register a callback that will be triggered before invoking a command.
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.BeforeCommandExecute, (event) => {})` instead.
+   * @param {CommandListener} callback The callback.
+   * @returns {IDisposable} The disposable instance.
+   */
+  onBeforeCommandExecute(e) {
+    return this._commandService.beforeCommandExecuted((t, r) => {
+      e(t, r);
+    });
+  }
+  /**
+   * Register a callback that will be triggered when a command is invoked.
+   * @deprecated use `univerAPI.addEvent(univerAPI.Event.CommandExecuted, (event) => {})` instead.
+   * @param {CommandListener} callback The callback.
+   * @returns {IDisposable} The disposable instance.
+   */
+  onCommandExecuted(e) {
+    return this._commandService.onCommandExecuted((t, r) => {
+      e(t, r);
+    });
+  }
+  /**
+   * Execute a command with the given id and parameters.
+   * @param id Identifier of the command.
+   * @param params Parameters of this execution.
+   * @param options Options of this execution.
+   * @returns The result of the execution. It is a boolean value by default which indicates the command is executed.
+   *
+   * @example
+   * ```ts
+   * univerAPI.executeCommand('sheet.command.set-range-values', {
+   *   value: { v: "Hello, Univer!" },
+   *   range: { startRow: 0, startColumn: 0, endRow: 0, endColumn: 0 }
+   * });
+   * ```
+   */
+  executeCommand(e, t, r) {
+    return this._commandService.executeCommand(e, t, r);
+  }
+  /**
+   * Execute a command with the given id and parameters synchronously.
+   * @param id Identifier of the command.
+   * @param params Parameters of this execution.
+   * @param options Options of this execution.
+   * @returns The result of the execution. It is a boolean value by default which indicates the command is executed.
+   *
+   * @example
+   * ```ts
+   * univerAPI.syncExecuteCommand('sheet.command.set-range-values', {
+   *   value: { v: "Hello, Univer!" },
+   *   range: { startRow: 0, startColumn: 0, endRow: 0, endColumn: 0 }
+   * });
+   * ```
+   */
+  syncExecuteCommand(e, t, r) {
+    return this._commandService.syncExecuteCommand(e, t, r);
+  }
+  /**
+   * Get hooks.
+   * @deprecated use `addEvent` instead.
+   * @returns {FHooks} FHooks instance
+   */
+  getHooks() {
+    return this._injector.createInstance(P);
+  }
+  get Enum() {
+    return R.get();
+  }
+  get Event() {
+    return O.get();
+  }
+  get Util() {
+    return H.get();
+  }
+  /**
+   * Add an event listener
+   * @param {string} event key of event
+   * @param {(params: IEventParamConfig[typeof event]) => void} callback callback when event triggered
+   * @returns {Disposable} The Disposable instance, for remove the listener
+   * @example
+   * ```ts
+   * // Add life cycle changed event listener
+   * const disposable = univerAPI.addEvent(univerAPI.Event.LifeCycleChanged, (params) => {
+   *   const { stage } = params;
+   *   console.log('life cycle changed', params);
+   * });
+   *
+   * // Remove the event listener, use `disposable.dispose()`
+   * ```
+   */
+  addEvent(e, t) {
+    if (!e || !t) throw new Error("Cannot add empty event");
+    return this._eventRegistry.addEvent(e, t);
+  }
+  /**
+   * Fire an event, used in internal only.
+   * @param {string} event key of event
+   * @param {any} params params of event
+   * @returns {boolean} should cancel
+   * @example
+   * ```ts
+   * this.fireEvent(univerAPI.Event.LifeCycleChanged, params);
+   * ```
+   */
+  fireEvent(e, t) {
+    return this._eventRegistry.fireEvent(e, t);
+  }
+  getUserManager() {
+    return this._injector.createInstance(B);
+  }
+  /**
+   * Create a new blob.
+   * @returns {FBlob} The new blob instance
+   * @example
+   * ```ts
+   * const blob = univerAPI.newBlob();
+   * ```
+   */
+  newBlob() {
+    return this._injector.createInstance(S);
+  }
+  /**
+   * Create a new color.
+   * @returns {ColorBuilder} The new color instance
+   * @example
+   * ```ts
+   * const color = univerAPI.newColor();
+   * ```
+   */
+  newColor() {
+    return new Te();
+  }
+  /**
+   * Create a new rich text.
+   * @param {IDocumentData} data
+   * @returns {RichTextBuilder} The new rich text instance
+   * @example
+   * ```ts
+   * const richText = univerAPI.newRichText({ body: { dataStream: 'Hello World\r\n' } });
+   * const range = univerAPI.getActiveWorkbook().getActiveSheet().getRange('A1');
+   * range.setRichTextValueForCell(richText);
+   * ```
+   */
+  newRichText(e) {
+    return we.create(e);
+  }
+  /**
+   * Create a new rich text value.
+   * @param {IDocumentData} data - The rich text data
+   * @returns {RichTextValue} The new rich text value instance
+   * @example
+   * ```ts
+   * const richTextValue = univerAPI.newRichTextValue({ body: { dataStream: 'Hello World\r\n' } });
+   * const range = univerAPI.getActiveWorkbook().getActiveSheet().getRange('A1');
+   * range.setRichTextValueForCell(richTextValue);
+   * ```
+   */
+  newRichTextValue(e) {
+    return Re.create(e);
+  }
+  /**
+   * Create a new paragraph style.
+   * @param {IParagraphStyle} style - The paragraph style
+   * @returns {ParagraphStyleBuilder} The new paragraph style instance
+   * @example
+   * ```ts
+   * const richText = univerAPI.newRichText({ body: { dataStream: 'Hello World\r\n' } });
+   * const paragraphStyle = univerAPI.newParagraphStyle({ textStyle: { ff: 'Arial', fs: 12, it: univerAPI.Enum.BooleanNumber.TRUE, bl: univerAPI.Enum.BooleanNumber.TRUE } });
+   * richText.insertParagraph(paragraphStyle);
+   * const range = univerAPI.getActiveWorkbook().getActiveSheet().getRange('A1');
+   * range.setRichTextValueForCell(richText);
+   * ```
+   */
+  newParagraphStyle(e) {
+    return Oe.create(e);
+  }
+  /**
+   * Create a new paragraph style value.
+   * @param {IParagraphStyle} style - The paragraph style
+   * @returns {ParagraphStyleValue} The new paragraph style value instance
+   * @example
+   * ```ts
+   * const paragraphStyleValue = univerAPI.newParagraphStyleValue();
+   * ```
+   */
+  newParagraphStyleValue(e) {
+    return Pe.create(e);
+  }
+  /**
+   * Create a new text style.
+   * @param {ITextStyle} style - The text style
+   * @returns {TextStyleBuilder} The new text style instance
+   * @example
+   * ```ts
+   * const textStyle = univerAPI.newTextStyle();
+   * ```
+   */
+  newTextStyle(e) {
+    return je.create(e);
+  }
+  /**
+   * Create a new text style value.
+   * @param {ITextStyle} style - The text style
+   * @returns {TextStyleValue} The new text style value instance
+   * @example
+   * ```ts
+   * const textStyleValue = univerAPI.newTextStyleValue();
+   * ```
+   */
+  newTextStyleValue(e) {
+    return Be.create(e);
+  }
+  /**
+   * Create a new text decoration.
+   * @param {ITextDecoration} decoration - The text decoration
+   * @returns {TextDecorationBuilder} The new text decoration instance
+   * @example
+   * ```ts
+   * const decoration = univerAPI.newTextDecoration();
+   * ```
+   */
+  newTextDecoration(e) {
+    return new He(e);
+  }
+};
+U = Je([
+  b(0, l(_)),
+  b(1, y),
+  b(2, A),
+  b(3, l(I))
+], U);
+export {
+  $ as FBase,
+  Ue as FBaseInitialable,
+  S as FBlob,
+  R as FEnum,
+  O as FEventName,
+  P as FHooks,
+  U as FUniver,
+  H as FUtil
+};