@univerjs/core 0.1.16 → 0.2.0

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/common/interceptor.d.ts

@@ -10,7 +10,7 @@ export type IComposeInterceptors<T = any, C = any> = (interceptors: Array<IInter
 /**
  * A helper to compose a certain type of interceptors.
  */
-export declare const composeInterceptors: <T, C>(interceptors: Array<IInterceptor<T, C>>) => (initValue: Nullable<T>, initContext: C) => Nullable<T>;
+export declare const composeInterceptors: <T, C>(interceptors: Array<IInterceptor<T, C>>) => ReturnType<IComposeInterceptors<T, C>>;
 export declare class InterceptorManager<P extends Record<string, IInterceptor<any, any>>> {
     private _interceptorsByName;
     private _interceptorPoints;

package/lib/types/{observer/index.d.ts → common/url.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 function isLegalUrl(url: string): boolean;

package/lib/types/docs/data-model/document-data-model.d.ts

@@ -44,15 +44,15 @@ export declare class DocumentDataModel extends DocumentDataModelSimple {
     dispose(): void;
     getDrawings(): IDrawings | undefined;
     getDrawingsOrder(): string[] | undefined;
+    getCustomRanges(): import('../../types/interfaces/i-document-data').ICustomRange[] | undefined;
+    getCustomDecorations(): import('../../types/interfaces/i-document-data').ICustomDecoration[] | undefined;
     getRev(): number;
     incrementRev(): void;
     getSettings(): import('../../types/interfaces/i-document-data').IDocumentSettings | undefined;
     reset(snapshot: Partial<IDocumentData>): void;
     getSelfOrHeaderFooterModel(segmentId?: string): DocumentDataModel;
     getUnitId(): string;
-    apply(actions: JSONXActions): string | number | boolean | import('ot-json1').Doc[] | {
-        [k: string]: import('ot-json1').Doc;
-    } | null | undefined;
+    apply(actions: JSONXActions): IDocumentData | undefined;
     sliceBody(startOffset: number, endOffset: number): Nullable<IDocumentBody>;
     private _initializeHeaderFooterModel;
     updateDocumentId(unitId: string): void;

package/lib/types/docs/data-model/json-x/json-x.d.ts

@@ -34,5 +34,5 @@ export declare class JSONX {
     moveOp(from: Path, to: Path): JSONOp;
     insertOp(path: Path, value: any): JSONOp;
     replaceOp(path: Path, oldVal: any, newVal: any): JSONOp;
-    editOp(subOp: TextXAction[]): JSONOp;
+    editOp(subOp: TextXAction[], path?: string[]): JSONOp;
 }

package/lib/types/docs/data-model/text-x/apply-utils/common.d.ts

@@ -1,4 +1,4 @@
-import { ICustomBlock, ICustomRange, IDocumentBody, IParagraph, ISectionBreak, ITable, ITextRun } from '../../../../types/interfaces';
+import { ICustomBlock, ICustomDecoration, ICustomRange, IDocumentBody, IParagraph, ISectionBreak, ITable, ITextRun } from '../../../../types/interfaces';
 
 export declare function normalizeTextRuns(textRuns: ITextRun[]): ITextRun[];
 /**
@@ -22,9 +22,12 @@ export declare function insertSectionBreaks(body: IDocumentBody, insertBody: IDo
 export declare function insertCustomBlocks(body: IDocumentBody, insertBody: IDocumentBody, textLength: number, currentIndex: number): void;
 export declare function insertTables(body: IDocumentBody, insertBody: IDocumentBody, textLength: number, currentIndex: number): void;
 export declare function insertCustomRanges(body: IDocumentBody, insertBody: IDocumentBody, textLength: number, currentIndex: number): void;
+export declare function mergeDecorations(customDecorations: ICustomDecoration[]): ICustomDecoration[];
+export declare function insertCustomDecorations(body: IDocumentBody, insertBody: IDocumentBody, textLength: number, currentIndex: number): void;
 export declare function deleteTextRuns(body: IDocumentBody, textLength: number, currentIndex: number): ITextRun[];
 export declare function deleteParagraphs(body: IDocumentBody, textLength: number, currentIndex: number): IParagraph[];
 export declare function deleteSectionBreaks(body: IDocumentBody, textLength: number, currentIndex: number): ISectionBreak[];
 export declare function deleteCustomBlocks(body: IDocumentBody, textLength: number, currentIndex: number): ICustomBlock[];
 export declare function deleteTables(body: IDocumentBody, textLength: number, currentIndex: number): ITable[];
 export declare function deleteCustomRanges(body: IDocumentBody, textLength: number, currentIndex: number): ICustomRange[];
+export declare function deleteCustomDecorations(body: IDocumentBody, textLength: number, currentIndex: number, needOffset?: boolean): ICustomDecoration[];

package/lib/types/docs/data-model/text-x/utils.d.ts

@@ -1,7 +1,19 @@
 import { UpdateDocsAttributeType } from '../../../shared/command-enum';
-import { IDocumentBody } from '../../../types/interfaces/i-document-data';
+import { ICustomDecoration, IDocumentBody } from '../../../types/interfaces/i-document-data';
 import { IRetainAction } from './action-types';
 
 export declare function getBodySlice(body: IDocumentBody, startOffset: number, endOffset: number, returnEmptyTextRun?: boolean): IDocumentBody;
+export declare function normalizeBody(body: IDocumentBody): IDocumentBody;
+export declare function getCustomRangeSlice(body: IDocumentBody, startOffset: number, endOffset: number): {
+    customRanges: {
+        startIndex: number;
+        endIndex: number;
+        rangeId: string;
+        rangeType: import('../../../types/interfaces/i-document-data').CustomRangeType;
+    }[];
+    leftOffset: number;
+    rightOffset: number;
+};
+export declare function getCustomDecorationSlice(body: IDocumentBody, startOffset: number, endOffset: number): ICustomDecoration[];
 export declare function composeBody(thisBody: IDocumentBody, otherBody: IDocumentBody, coverType?: UpdateDocsAttributeType): IDocumentBody;
 export declare function isUselessRetainAction(action: IRetainAction): boolean;

package/lib/types/docs/data-model/types.d.ts

@@ -28,8 +28,8 @@ export declare enum DataStreamTreeTokenType {
     TABLE_ROW_START = "\u001B",// 表格开始
     TABLE_CELL_START = "\u001C",// 表格开始
     TABLE_CELL_END = "\u001D",// 表格开始
-    TABLE_ROW_END = "\u001E",// 表格开始
-    TABLE_END = "\u001F",// 表格结束
+    TABLE_ROW_END = "*",// 表格开始
+    TABLE_END = "+",// 表格结束
     CUSTOM_RANGE_START = "\u001F",// 自定义范围开始
     CUSTOM_RANGE_END = "\u001E",// 自定义范围结束
     COLUMN_BREAK = "\v",// 换列

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,8 @@ 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';
+export { normalizeBody, getCustomRangeSlice, getCustomDecorationSlice } from './docs/data-model/text-x/utils';
+export { updateAttributeByDelete } from './docs/data-model/text-x/apply-utils/delete-apply';
+export { updateAttributeByInsert } from './docs/data-model/text-x/apply-utils/insert-apply';
+export { nameCharacterCheck } from './shared/name';

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/__tests__/index.d.ts

@@ -0,0 +1,18 @@
+import { ICommandService, Univer } from '@univerjs/core';
+import { Dependency } from '@wendellhu/redi';
+
+export declare const createTestBed: (dependencies?: Dependency[]) => {
+    univer: Univer;
+    get: {
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, lookUp?: import('@wendellhu/redi').LookUp): T;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.MANY, lookUp?: import('@wendellhu/redi').LookUp): T[];
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.OPTIONAL, lookUp?: import('@wendellhu/redi').LookUp): T | null;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.REQUIRED, lookUp?: import('@wendellhu/redi').LookUp): T;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity?: import('@wendellhu/redi').Quantity, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantityOrLookup?: import('@wendellhu/redi').Quantity | import('@wendellhu/redi').LookUp, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
+    };
+    workbook: import('@univerjs/core').Workbook;
+    unitId: string;
+    subUnitId: string;
+    commandService: ICommandService;
+};

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

@@ -84,6 +84,7 @@ export interface IExecutionOptions {
     onlyLocal?: boolean;
     /** This command is from collaboration peers. */
     fromCollab?: boolean;
+    fromChangeset?: boolean;
     [key: PropertyKey]: string | number | boolean | undefined;
 }
 export type CommandListener = (commandInfo: Readonly<ICommandInfo>, options?: IExecutionOptions) => void;

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/resource-loader/resource-loader.service.d.ts

@@ -3,6 +3,7 @@ import { IWorkbookData } from '../../types/interfaces';
 import { IResourceManagerService } from '../resource-manager/type';
 import { IUniverInstanceService } from '../instance/instance.service';
 import { Disposable } from '../../shared/lifecycle';
+import { DocumentDataModel } from '../../docs';
 import { IResourceLoaderService } from './type';
 
 export declare class ResourceLoaderService extends Disposable implements IResourceLoaderService {
@@ -11,4 +12,5 @@ export declare class ResourceLoaderService extends Disposable implements IResour
     constructor(_resourceManagerService: IResourceManagerService, _univerInstanceService: IUniverInstanceService);
     private _init;
     saveWorkbook: (workbook: Workbook) => IWorkbookData;
+    saveDoc(doc: DocumentDataModel): import('../../types/interfaces').IDocumentData;
 }

package/lib/types/services/resource-loader/type.d.ts

@@ -1,7 +1,10 @@
 import { Workbook } from '../../sheets/workbook';
 import { IWorkbookData } from '../../types/interfaces/i-workbook-data';
+import { IDocumentData } from '../../types/interfaces';
+import { DocumentDataModel } from '../../docs';
 
 export interface IResourceLoaderService {
     saveWorkbook: (workbook: Workbook) => IWorkbookData;
+    saveDoc: (doc: DocumentDataModel) => IDocumentData;
 }
 export declare const IResourceLoaderService: import('@wendellhu/redi').IdentifierDecorator<IResourceLoaderService>;

package/lib/types/services/resource-manager/resource-manager.service.d.ts

@@ -1,5 +1,6 @@
 import { Disposable } from '../../shared/lifecycle';
 import { IWorkbookData } from '../../types/interfaces/i-workbook-data';
+import { UniverInstanceType } from '../../common/unit';
 import { IResourceHook, IResourceManagerService, IResourceName } from './type';
 
 export declare class ResourceManagerService extends Disposable implements IResourceManagerService {
@@ -11,6 +12,10 @@ export declare class ResourceManagerService extends Disposable implements IResou
         name: `SHEET_${string}_PLUGIN` | `DOC_${string}_PLUGIN`;
         data: string;
     }[];
+    getResourcesByType(unitId: string, type: UniverInstanceType): {
+        name: `SHEET_${string}_PLUGIN` | `DOC_${string}_PLUGIN`;
+        data: string;
+    }[];
     registerPluginResource<T = unknown>(hook: IResourceHook<T>): import('@wendellhu/redi').IDisposable;
     disposePluginResource(pluginName: IResourceName): void;
     loadResources(unitId: string, resources: IWorkbookData['resources']): void;

package/lib/types/services/resource-manager/type.d.ts

@@ -19,6 +19,7 @@ export interface IResourceManagerService {
     disposePluginResource: (pluginName: IResourceName) => void;
     getAllResourceHooks: () => IResourceHook[];
     getResources: (unitId: string) => IWorkbookData['resources'];
+    getResourcesByType: (unitId: string, type: UniverInstanceType) => IWorkbookData['resources'];
     loadResources: (unitId: string, resources: IWorkbookData['resources']) => void;
     unloadResources(unitId: string): void;
 }

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/services/user-manager/user-manager.service.d.ts

@@ -22,10 +22,10 @@ export declare class UserManagerService {
     private _model;
     private _userChange$;
     userChange$: import('rxjs').Observable<{
-        type: 'add' | 'delete';
+        type: "add" | "delete";
         user: IUser;
     } | {
-        type: 'clear';
+        type: "clear";
     }>;
     private _currentUser$;
     /**

package/lib/types/shared/__tests__/name.spec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

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

@@ -1,11 +1,11 @@
 import { IRange } from '../types/interfaces';
 import { ICellData, ICellDataForSheetInterceptor } from '../types/interfaces/i-cell-data';
 import { IDocumentData } from '../types/interfaces/i-document-data';
-import { IRangeWithCoord, ISelectionCell, ISelectionCellWithCoord } from '../types/interfaces/i-selection-data';
+import { IRangeWithCoord, ISelectionCell, ISelectionCellWithMergeInfo } from '../types/interfaces/i-selection-data';
 import { IColorStyle, IStyleData } from '../types/interfaces/i-style-data';
 import { Nullable } from './types';
 
-export declare function makeCellToSelection(cellInfo: Nullable<ISelectionCellWithCoord>): Nullable<IRangeWithCoord>;
+export declare function makeCellToSelection(cellInfo: Nullable<ISelectionCellWithMergeInfo>): Nullable<IRangeWithCoord>;
 export declare function makeCellRangeToRangeData(cellInfo: Nullable<ISelectionCell>): Nullable<IRange>;
 export declare function isEmptyCell(cell: Nullable<ICellData>): boolean;
 export declare function isCellCoverable(cell: Nullable<ICellDataForSheetInterceptor>): boolean;
@@ -22,11 +22,6 @@ export declare function isFormulaString(value: any): boolean;
  * @returns
  */
 export declare function isFormulaId(value: any): boolean;
-/**
- * Convert rich text json to DOM
- * @param p
- */
-export declare function handleJsonToDom(p: IDocumentData): string;
 /**
  * transform style object to string
  * @param style

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/name.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The name you entered for the worksheet or chart is invalid. Please ensure:
+
+    The name is no more than 31 characters.
+    The first and last characters cannot be '
+    The name does not contain any of the following characters: : \ / ? * [ or ].
+    The name is not empty.
+ * @param name
+ * @returns
+ */
+export declare function nameCharacterCheck(name: string): boolean;

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/shared/tools.d.ts

@@ -36,6 +36,7 @@ export declare class Tools {
     static isWeChat(): boolean;
     static isAndroid(): boolean;
     static isIPhone(): boolean;
+    static isLegalUrl(url: string): boolean;
     static itCount(count: number): Function;
     static hasLength(target: IArguments | any[] | string, length?: number): boolean;
     static capitalize(str: string): string;
@@ -105,4 +106,5 @@ export declare class Tools {
      * @param value
      */
     static set(data: Record<string, any>, propertyPath: string, value: any): void;
+    static clamp(value: number, min: number, max: number): number;
 }

package/lib/types/sheets/__tests__/create-core-test-bed.d.ts

@@ -4,12 +4,12 @@ import { IWorkbookData } from '../../types/interfaces/i-workbook-data';
 export declare function createCoreTestBed(workbookData?: IWorkbookData): {
     univer: Univer;
     get: {
-        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, lookUp?: import('@wendellhu/redi').LookUp | undefined): T;
-        <T_1>(id: import('@wendellhu/redi').DependencyIdentifier<T_1>, quantity: import("@wendellhu/redi").Quantity.MANY, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_1[];
-        <T_2>(id: import('@wendellhu/redi').DependencyIdentifier<T_2>, quantity: import("@wendellhu/redi").Quantity.OPTIONAL, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_2 | null;
-        <T_3>(id: import('@wendellhu/redi').DependencyIdentifier<T_3>, quantity: import("@wendellhu/redi").Quantity.REQUIRED, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_3;
-        <T_4>(id: import('@wendellhu/redi').DependencyIdentifier<T_4>, quantity?: import('@wendellhu/redi').Quantity | undefined, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_4 | T_4[] | null;
-        <T_5>(id: import('@wendellhu/redi').DependencyIdentifier<T_5>, quantityOrLookup?: import('@wendellhu/redi').Quantity | import('@wendellhu/redi').LookUp | undefined, lookUp?: import('@wendellhu/redi').LookUp | undefined): T_5 | T_5[] | null;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, lookUp?: import('@wendellhu/redi').LookUp): T;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.MANY, lookUp?: import('@wendellhu/redi').LookUp): T[];
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.OPTIONAL, lookUp?: import('@wendellhu/redi').LookUp): T | null;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity: import("@wendellhu/redi").Quantity.REQUIRED, lookUp?: import('@wendellhu/redi').LookUp): T;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantity?: import('@wendellhu/redi').Quantity, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
+        <T>(id: import('@wendellhu/redi').DependencyIdentifier<T>, quantityOrLookup?: import('@wendellhu/redi').Quantity | import('@wendellhu/redi').LookUp, lookUp?: import('@wendellhu/redi').LookUp): T[] | T | null;
     };
     sheet: import('../workbook').Workbook;
 };

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

@@ -1,5 +1,5 @@
 import { IObjectMatrixPrimitiveType, Nullable, ObjectMatrix } from '../shared';
-import { HorizontalAlign, VerticalAlign, WrapStrategy, BooleanNumber, FontItalic, FontWeight } from '../types/enum';
+import { HorizontalAlign, VerticalAlign, BooleanNumber, FontItalic, FontWeight, WrapStrategy } from '../types/enum';
 import { IBorderData, ICellData, IDocumentBody, IDocumentData, IRange, IStyleBase, IStyleData, ITextDecoration, ITextRotation } from '../types/interfaces';
 import { Styles } from './styles';
 import { Worksheet } from './worksheet';
@@ -275,10 +275,6 @@ export declare class Range {
      * Returns whether the text in the cell wraps.
      */
     getWrap(): BooleanNumber;
-    /**
-     * Returns whether the text in the cells wrap.
-     */
-    getWraps(): BooleanNumber[][];
     /**
      * Returns the text wrapping strategies for the cells in the range.
      */

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/types/const/clipboard.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright 2023-present DreamNum Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const skipParseTagNames: string[];