@univerjs/core 0.1.16 → 0.1.17

package/lib/types/common/array.d.ts

@@ -29,3 +29,4 @@ export declare function findLast<T>(arr: T[], callback: (item: T, index: number)
  */
 export declare function rotate<T>(arr: Readonly<T[]>, steps: number): readonly T[];
 export declare function groupBy<T>(arr: Readonly<T[]>, keyFn: (v: T) => string): Map<string, T[]>;
+export declare function makeArray<T>(thing: T | T[]): T[];

package/lib/types/common/const.d.ts

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const DOCS_NORMAL_EDITOR_UNIT_ID_KEY = "__defaultDocumentNormalEditorSpecialUnitId_20231006__";
-export declare const DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY = "__defaultDocumentFormulaBarEditorSpecialUnitId_20231012__";
+export declare const DOCS_NORMAL_EDITOR_UNIT_ID_KEY = "__INTERNAL_EDITOR__DOCS_NORMAL";
+export declare const DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY = "__INTERNAL_EDITOR__DOCS_FORMULA_BAR";
 export declare const DEFAULT_EMPTY_DOCUMENT_VALUE = "\r\n";
 export declare function createInternalEditorID(id: string): string;
 export declare function isInternalEditorID(id: string): boolean;

package/lib/types/index.d.ts

@@ -20,7 +20,7 @@ export { Univer } from './univer';
 export { shallowEqual, isRangesEqual, isUnitRangesEqual } from './common/equal';
 export { isNumeric, isSafeNumeric } from './common/number';
 export { isBooleanString } from './common/boolean';
-export { dedupe, remove, rotate, groupBy } from './common/array';
+export { dedupe, remove, rotate, groupBy, makeArray } from './common/array';
 export { mergeSets } from './common/set';
 export { DEFAULT_EMPTY_DOCUMENT_VALUE, DOCS_FORMULA_BAR_EDITOR_UNIT_ID_KEY, DOCS_NORMAL_EDITOR_UNIT_ID_KEY, createInternalEditorID, isInternalEditorID, } from './common/const';
 export { throttle } from './common/function';
@@ -37,7 +37,7 @@ export type { TPriority } from './docs/data-model/text-x/text-x';
 export { JSONX, JSON1 } from './docs/data-model/json-x/json-x';
 export type { JSONXActions, JSONXPath } from './docs/data-model/json-x/json-x';
 export { replaceInDocumentBody } from './docs/data-model/replacement';
-export * from './observer';
+export { type IEventObserver, EventState, EventSubject } from './observer/observable';
 export { Plugin } from './services/plugin/plugin';
 export { PluginService, DependentOn } from './services/plugin/plugin.service';
 export { type CommandListener, CommandService, CommandType, type ICommand, type ICommandInfo, ICommandService, type IExecutionOptions, type IMultiCommand, type IMutation, type IMutationCommonParams, type IMutationInfo, type IOperation, type IOperationInfo, NilCommand, sequenceExecute, sequenceExecuteAsync, } from './services/command/command.service';
@@ -105,3 +105,4 @@ export { PermissionService } from './services/permission/permission.service';
 export { AuthzIoLocalService } from './services/authz-io/authz-io-local.service';
 export { IAuthzIoService } from './services/authz-io/type';
 export { createDefaultUser } from './services/user-manager/const';
+export { skipParseTagNames } from './types/const/clipboard';

package/lib/types/observer/observable.d.ts

@@ -1,4 +1,4 @@
-import { Nullable } from '../shared/types';
+import { Observer as RxObserver, Subscription, Subject } from 'rxjs';
 
 /**
  * A class serves as a medium between the observable and its observers
@@ -7,145 +7,41 @@ export declare class EventState {
     /**
      * An WorkBookObserver can set this property to true to prevent subsequent observers of being notified
      */
-    skipNextObservers: boolean | undefined;
+    skipNextObservers: boolean;
     /**
      * This will be populated with the return value of the last function that was executed.
      * If it is the first function in the callback chain it will be the event data.
      */
     lastReturnValue?: unknown;
     isStopPropagation: boolean;
-    /**
-     * Create a new EventState
-     * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
-     * @param target defines the original target of the state
-     * @param currentTarget defines the current target of the state
-     */
-    constructor(skipNextObservers?: boolean);
-    /**
-     * Initialize the current event state
-     * @param skipNextObservers defines a flag which will instruct the observable to skip following observers when set to true
-     * @param target defines the original target of the state
-     * @param currentTarget defines the current target of the state
-     * @returns the current event state
-     */
-    initialize(skipNextObservers?: boolean): EventState;
     stopPropagation(): void;
 }
 interface INotifyObserversReturn {
+    /** If the event has been handled by any event handler. */
+    handled: boolean;
     lastReturnValue: unknown;
     stopPropagation: boolean;
 }
-export declare function isObserver(value: any): boolean;
-/**
- * Represent an WorkBookObserver registered to a given Observable object.
- * The current implementation of the rendering layer is still in use.
- *
- * @deprecated use rxjs instead
- */
-export declare class Observer<T = void> {
-    /**
-     * Defines the callback to call when the observer is notified
-     */
-    callback: (eventData: T, eventState: EventState) => void;
-    observable: Observable<T>;
-    dispose(): void;
-    /**
-     * Creates a new observer
-     * @param callback defines the callback to call when the observer is notified
-     */
-    constructor(
-    /**
-     * Defines the callback to call when the observer is notified
-     */
-    callback: (eventData: T, eventState: EventState) => void, observable: Observable<T>);
+export interface IEventObserver<T> extends Partial<RxObserver<[T, EventState]>> {
+    next?: (value: [T, EventState]) => unknown;
+    priority?: number;
 }
 /**
- * The Observable class is a simple implementation of the Observable pattern.
- * The current implementation of the rendering layer is still in use.
+ * This is a custom implementation of RxJS subject. It handles events on canvas elements.
+ * In addition to the event, it also emits a state object that can be used to controls the
+ * propagation of the event.
  *
- * @deprecated use rxjs instead
- *
- * @remarks
- * There's one slight particularity though: a given Observable can notify its observer using a particular mask value, only the Observers registered with this mask value will be notified.
- * This enable a more fine grained execution without having to rely on multiple different Observable objects.
- * For instance you may have a given Observable that have four different types of notifications: Move (mask = 0x01), Stop (mask = 0x02), Turn Right (mask = 0X04), Turn Left (mask = 0X08).
- * A given observer can register itself with only Move and Stop (mask = 0x03), then it will only be notified when one of these two occurs and will never be for Turn Left/Right.
  */
-export declare class Observable<T> {
-    protected _observers: Observer<T>[];
-    protected _eventState: EventState;
-    protected _onObserverAdded: Nullable<(observer: Observer<T>) => void> | undefined;
-    /**
-     * Creates a new observable
-     * @param onObserverAdded defines a callback to call when a new observer is added
-     */
-    constructor(onObserverAdded?: (observer: Observer<T>) => void);
-    /**
-     * Gets the list of observers
-     */
-    get observers(): Array<Observer<T>>;
-    /**
-     * Create a new WorkBookObserver with the specified callback
-     * @param callback the callback that will be executed for that WorkBookObserver
-     * @param insertFirst if true the callback will be inserted at the first position, hence executed before the others ones. If false (default behavior) the callback will be inserted at the last position, executed after all the others already present.
-     * @param unregisterOnFirstCall defines if the observer as to be unregistered after the next notification
-     * @returns the new observer created for the callback
-     */
-    add(callback: (eventData: T, eventState: EventState) => void, insertFirst?: boolean): Nullable<Observer<T>>;
-    /**
-     * Remove an WorkBookObserver from the Observable object
-     * @param observer the instance of the WorkBookObserver to remove
-     * @returns false if it doesn't belong to this Observable
-     */
-    remove(observer: Nullable<Observer<T>>): boolean;
-    /**
-     * Moves the observable to the top of the observer list making it get called first when notified
-     * @param observer the observer to move
-     */
-    makeObserverTopPriority(observer: Observer<T>): void;
-    /**
-     * Moves the observable to the bottom of the observer list making it get called last when notified
-     * @param observer the observer to move
-     */
-    makeObserverBottomPriority(observer: Observer<T>): void;
-    /**
-     * Notify all Observers by calling their respective callback with the given data
-     * Will return true if all observers were executed, false if an observer set skipNextObservers to true, then prevent the subsequent ones to execute
-     * @param eventData defines the data to send to all observers
-     * @returns false if the complete observer chain was not processed (because one observer set the skipNextObservers to true)
-     */
-    notifyObservers(eventData: T): Nullable<INotifyObserversReturn>;
-    /**
-     * Calling this will execute each callback, expecting it to be a promise or return a value.
-     * If at any point in the chain one function fails, the promise will fail and the execution will not continue.
-     * This is useful when a chain of Events (sometimes async Events) is needed to initialize a certain object
-     * and it is crucial that all callbacks will be executed.
-     * The order of the callbacks is kept, callbacks are not executed parallel.
-     *
-     * @param eventData The data to be sent to each callback
-     * @returns {Promise<T>} will return a Promise than resolves when all callbacks executed successfully.
-     */
-    notifyObserversWithPromise(eventData: T): Promise<T>;
-    /**
-     * Notify a specific observer
-     * @param observer defines the observer to notify
-     * @param eventData defines the data to be sent to each callback
-     */
-    notifyObserver(observer: Observer<T>, eventData: T): Nullable<INotifyObserversReturn>;
-    /**
-     * Gets a boolean indicating if the observable has at least one observer
-     * @returns true is the Observable has at least one WorkBookObserver registered
-     */
-    hasObservers(): boolean;
-    /**
-     * Clear the list of observers
-     */
-    clear(): void;
-    /**
-     * Clone the current observable
-     * @returns a new observable
-     */
-    clone(): Observable<T>;
-    private _remove;
+export declare class EventSubject<T> extends Subject<[T, EventState]> {
+    private _sortedObservers;
+    /** @deprecated Use `subscribeEvent` instead. */
+    subscribe(): Subscription;
+    /** @deprecated Use `emitEvent` instead. */
+    next(): void;
+    unsubscribe(): void;
+    complete(): void;
+    subscribeEvent(observer: IEventObserver<T> | ((evt: T, state: EventState) => unknown)): Subscription;
+    clearObservers(): void;
+    emitEvent(event: T): INotifyObserversReturn;
 }
 export {};

package/lib/types/services/instance/instance.service.d.ts

@@ -18,7 +18,7 @@ export interface IUniverInstanceService {
     unitAdded$: Observable<UnitModel>;
     /** Subscribe to curtain type of units' creation. */
     getTypeOfUnitAdded$<T extends UnitModel>(type: UnitType): Observable<T>;
-    /** @interal */
+    /** @ignore */
     __addUnit(unit: UnitModel): void;
     /** Omits value when a UnitModel is disposed. */
     unitDisposed$: Observable<UnitModel>;

package/lib/types/services/undoredo/undoredo.service.d.ts

@@ -21,7 +21,7 @@ export interface IUndoRedoService {
     pitchTopRedoElement(): Nullable<IUndoRedoItem>;
     popUndoToRedo(): void;
     popRedoToUndo(): void;
-    clearUndoRedo(unitID: string): void;
+    clearUndoRedo(unitId: string): void;
     /**
      * Batch undo redo elements into a single `IUndoRedoItem` util the returned `IDisposable` is called.
      *

package/lib/types/shared/lifecycle.d.ts

@@ -1,11 +1,8 @@
 import { IDisposable } from '@wendellhu/redi';
 import { Subscription, SubscriptionLike, Subject } from 'rxjs';
-import { Nullable } from '../common/type-util';
-import { Observer } from '../observer/observable';
 
-type DisposableLike = IDisposable | Nullable<Observer<any>> | SubscriptionLike | (() => void);
+type DisposableLike = IDisposable | SubscriptionLike | (() => void);
 export declare function toDisposable(disposable: IDisposable): IDisposable;
-export declare function toDisposable(observer: Nullable<Observer<any>>): IDisposable;
 export declare function toDisposable(subscription: SubscriptionLike): IDisposable;
 export declare function toDisposable(callback: () => void): IDisposable;
 export declare function toDisposable(v: DisposableLike): IDisposable;

package/lib/types/shared/rxjs.d.ts

@@ -2,5 +2,14 @@ import { IDisposable } from '@wendellhu/redi';
 import { Observable } from 'rxjs';
 
 type CallbackFn<T extends readonly unknown[]> = (cb: (...args: T) => void) => IDisposable;
+/**
+ * Creates an observable from a callback function.
+ *
+ * @param callback The callback function that will be called when the observable is subscribed to. **Please not that the
+ * if the callback function has `this` context, it will be lost when the callback is called. So you probably
+ * should bind the callback to the correct context.**
+ *
+ * @returns The observable that will emit when the callback function gets called.
+ */
 export declare function fromCallback<T extends readonly unknown[]>(callback: CallbackFn<T>): Observable<T>;
 export {};

package/lib/types/sheets/workbook.d.ts

@@ -83,6 +83,7 @@ export declare class Workbook extends UnitModel<IWorkbookData, UniverInstanceTyp
     getSheetBySheetId(sheetId: string): Nullable<Worksheet>;
     getSheetByIndex(index: number): Nullable<Worksheet>;
     getHiddenWorksheets(): string[];
+    getUnhiddenWorksheets(): string[];
     load(config: IWorkbookData): void;
     /**
      * Check if sheet name is unique

package/lib/types/{observer/index.d.ts → types/const/clipboard.d.ts}

@@ -13,5 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export * from './observable';
-export * from './observable-hooks';
+export declare const skipParseTagNames: string[];