@univerjs/find-replace 0.1.2 → 0.1.4

package/lib/index.css

@@ -1 +1 @@
-.univer-find-replace-expand-container{margin-top:16px;text-align:center}
+.univer-find-replace-dialog-container{display:block}.univer-find-replace-expand-container{margin-top:16px;text-align:center}.univer-find-replace-expand-container .univer-button-text{color:rgb(var(--primary-color))}.univer-find-replace-buttons-group{display:flex;justify-content:space-between;margin-top:24px}.univer-find-replace-buttons-group-right>button:not(:first-child){margin-left:8px}

package/lib/types/{views/dialog/Dialog.d.ts → commands/command/replace.command.d.ts}

@@ -13,5 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import React from 'react';
-export declare function FindReplaceDialog(): React.JSX.Element;
+import type { ICommand } from '@univerjs/core';
+export declare const ReplaceCurrentMatchCommand: ICommand;
+export declare const ReplaceAllMatchesCommand: ICommand;

package/lib/types/commands/operations/find-replace.operation.d.ts

@@ -16,7 +16,5 @@
 import type { IOperation } from '@univerjs/core';
 export declare const OpenFindDialogOperation: IOperation;
 export declare const OpenReplaceDialogOperation: IOperation;
-export declare const ToggleReplaceDialogOperation: IOperation;
-export declare const CloseFindReplaceDialogOperation: IOperation;
 export declare const GoToNextMatchOperation: IOperation;
 export declare const GoToPreviousMatchOperation: IOperation;

package/lib/types/controllers/find-replace.controller.d.ts

@@ -13,25 +13,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { ICommandService, IContextService, LocaleService, RxDisposable } from '@univerjs/core';
+import { ICommandService, IContextService, ILogService, IUniverInstanceService, LocaleService, RxDisposable } from '@univerjs/core';
 import { ComponentManager, IDialogService, ILayoutService, IMenuService, IShortcutService } from '@univerjs/ui';
 import { Injector } from '@wendellhu/redi';
 import { IFindReplaceService } from '../services/find-replace.service';
 export declare class FindReplaceController extends RxDisposable {
+    private readonly _univerInstanceService;
     private readonly _menuService;
     private readonly _shortcutService;
     private readonly _commandService;
     private readonly _findReplaceService;
+    private readonly _logService;
     private readonly _dialogService;
     private readonly _contextService;
     private readonly _layoutService;
     private readonly _localeService;
     private readonly _componentManager;
     private readonly _injector;
-    constructor(_menuService: IMenuService, _shortcutService: IShortcutService, _commandService: ICommandService, _findReplaceService: IFindReplaceService, _dialogService: IDialogService, _contextService: IContextService, _layoutService: ILayoutService, _localeService: LocaleService, _componentManager: ComponentManager, _injector: Injector);
-    private _initOperations;
-    private _initUI;
+    constructor(_univerInstanceService: IUniverInstanceService, _menuService: IMenuService, _shortcutService: IShortcutService, _commandService: ICommandService, _findReplaceService: IFindReplaceService, _logService: ILogService, _dialogService: IDialogService, _contextService: IContextService, _layoutService: ILayoutService, _localeService: LocaleService, _componentManager: ComponentManager, _injector: Injector);
+    private _initCommands;
     private _initShortcuts;
+    private _initUI;
     private _openPanel;
-    private _closePanel;
+    closePanel(): void;
 }

package/lib/types/controllers/find-replace.shortcut.d.ts

@@ -15,7 +15,7 @@
  */
 import { type IShortcutItem } from '@univerjs/ui';
 export declare const OpenFindDialogShortcutItem: IShortcutItem;
+export declare const MacOpenFindDialogShortcutItem: IShortcutItem;
 export declare const OpenReplaceDialogShortcutItem: IShortcutItem;
-export declare const CloseFRDialogShortcutItem: IShortcutItem;
 export declare const GoToNextFindMatchShortcutItem: IShortcutItem;
 export declare const GoToPreviousFindMatchShortcutItem: IShortcutItem;

package/lib/types/index.d.ts

@@ -14,5 +14,6 @@
  * limitations under the License.
  */
 export { UniverFindReplacePlugin } from './plugin';
-export type { IFindComplete, IFindMatch, IFindQuery, IFindReplaceProvider } from './services/find-replace.service';
-export { FindModel, IFindReplaceService } from './services/find-replace.service';
+export { FindReplaceController } from './controllers/find-replace.controller';
+export type { IFindComplete, IFindMoveParams, IFindMatch, IFindQuery, IFindReplaceProvider, IReplaceAllResult, } from './services/find-replace.service';
+export { FindModel, IFindReplaceService, FindBy, FindScope, FindDirection } from './services/find-replace.service';

package/lib/types/locale/en-US.d.ts

@@ -13,6 +13,52 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type zhCN from './zh-CN';
-declare const locale: typeof zhCN;
+declare const locale: {
+    'find-replace': {
+        toolbar: string;
+        shortcut: {
+            'open-find-dialog': string;
+            'open-replace-dialog': string;
+            'close-dialog': string;
+            'go-to-next-match': string;
+            'go-to-previous-match': string;
+        };
+        dialog: {
+            title: string;
+            find: string;
+            replace: string;
+            'replace-all': string;
+            'case-sensitive': string;
+            'find-placeholder': string;
+            'advanced-finding': string;
+            'replace-placeholder': string;
+            'match-the-whole-cell': string;
+            'find-direction': {
+                title: string;
+                row: string;
+                column: string;
+            };
+            'find-scope': {
+                title: string;
+                'current-sheet': string;
+                workbook: string;
+            };
+            'find-by': {
+                title: string;
+                value: string;
+                formula: string;
+            };
+            'no-match': string;
+            'no-result': string;
+        };
+        replace: {
+            'all-success': string;
+            'all-failure': string;
+            confirm: {
+                title: string;
+            };
+        };
+    };
+    'find-replace-shortcuts': string;
+};
 export default locale;

package/lib/types/locale/zh-CN.d.ts

@@ -13,20 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-declare const locale: {
-    univer: {
-        'find-replace': {
-            dialog: {
-                title: string;
-                find: string;
-                replace: string;
-                'replace-all': string;
-                'find-range': string;
-                'find-placeholder': string;
-                'advanced-finding': string;
-                'replace-placeholder': string;
-            };
-        };
-    };
-};
+import type enUS from './en-US';
+declare const locale: typeof enUS;
 export default locale;

package/lib/types/services/context-keys.d.ts

@@ -13,7 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+export declare const FIND_REPLACE_INPUT_FOCUS = "FIND_REPLACE_INPUT_FOCUS";
 /**
- * If find replace feature is activated.
+ * If find replace panel is focused.
  */
-export declare const FIND_REPLACE_ACTIVATED = "FIND_REPLACE_ACTIVATED";
+export declare const FIND_REPLACE_DIALOG_FOCUS = "FIND_REPLACE_DIALOG_FOCUS";
+/**
+ * If the find replace feature is activated and the replace is revealed.
+ */
+export declare const FIND_REPLACE_REPLACE_REVEALED = "FIND_REPLACE_REPLACE_REVEALED";

package/lib/types/services/find-replace.service.d.ts

@@ -13,10 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Disposable, ILogService, IUniverInstanceService } from '@univerjs/core';
+import type { Nullable } from '@univerjs/core';
+import { Disposable, IContextService, ILogService, IUniverInstanceService } from '@univerjs/core';
 import type { IDisposable } from '@wendellhu/redi';
 import { Injector } from '@wendellhu/redi';
 import type { Observable } from 'rxjs';
+import { BehaviorSubject } from 'rxjs';
 export type FindProgressFn = () => void;
 export interface IFindComplete<T extends IFindMatch = IFindMatch> {
     results: T[];
@@ -25,26 +27,64 @@ export interface IFindMatch<T = unknown> {
     provider: string;
     unitId: string;
     range: T;
+    /** Indicates if the match could be replaced. */
+    replaceable?: boolean;
+}
+export interface IFindMoveParams {
+    /** Go to next (previous) matching in a loop. */
+    loop?: boolean;
+    /** If the the selection is on the match and then should stay on the match. */
+    stayIfOnMatch?: boolean;
+    /**
+     * If this param is true, we should only change matching position without performing focusing.
+     * This usually happens when "moving" is triggered when a document's content changes.
+     */
+    noFocus?: boolean;
+}
+export interface IReplaceAllResult {
+    success: number;
+    failure: number;
 }
 export declare abstract class FindModel extends Disposable {
     abstract readonly unitId: string;
+    /**
+     * Find model should emit new matches from this observable if they changed no matter due to incremental
+     * or document's content changes.
+     */
+    abstract readonly matchesUpdate$: Observable<IFindMatch[]>;
+    abstract readonly activelyChangingMatch$: Observable<IFindMatch>;
     abstract getMatches(): IFindMatch[];
-    abstract moveToNextMatch(loop?: boolean): IFindMatch | null;
-    abstract moveToPreviousMatch(loop?: boolean): IFindMatch | null;
+    abstract moveToNextMatch(params?: IFindMoveParams): IFindMatch | null;
+    abstract moveToPreviousMatch(params?: IFindMoveParams): IFindMatch | null;
+    /** Replace the currently focused matching if there is one. */
+    abstract replace(replaceString: string): Promise<boolean>;
+    /**
+     * Replace all matches. This method would return how many
+     */
+    abstract replaceAll(replaceString: string): Promise<IReplaceAllResult>;
 }
 /**
  * A provider should be implemented by a business to provide the find results.
  */
 export interface IFindReplaceProvider {
     find(query: IFindQuery): Promise<FindModel[]>;
-    cancel(): void;
+    terminate(): void;
 }
+type IReplaceableMatch = IFindMatch & {
+    replaceable: boolean;
+};
 /**
  * This service works as a core of the find & replace feature.
  */
 export interface IFindReplaceService {
     readonly stateUpdates$: Observable<Partial<IFindReplaceState>>;
     readonly state$: Observable<IFindReplaceState>;
+    readonly currentMatch$: Observable<Nullable<IFindMatch>>;
+    /** An observable value of all matches those could be replaced. */
+    readonly replaceables$: Observable<IReplaceableMatch[]>;
+    readonly focusSignal$: Observable<void>;
+    readonly revealed: boolean;
+    readonly replaceRevealed: boolean;
     /**
      * Register a find replace provider to the service. The provider is the actual bearer to
      * perform the find in different kinds of documents or different environments.
@@ -52,98 +92,193 @@ export interface IFindReplaceService {
      * @param provider the find replace provider
      */
     registerFindReplaceProvider(provider: IFindReplaceProvider): IDisposable;
+    /**
+     * Get find string from the internal state.
+     */
+    getFindString(): string;
     /**
      * Start a find & replace session.
      *
-     * @returns if the find & replace session is created and user could start find replace
+     * @returns execution result
+     */
+    start(revealReplace?: boolean): boolean;
+    /**
+     * Terminate a find session and clear all caches.
      */
-    start(): boolean;
-    end(): boolean;
+    terminate(): void;
+    /**
+     * Start searching with the current conditions.
+     */
+    find(): void;
+    focusFindInput(): void;
     revealReplace(): void;
     changeFindString(value: string): void;
+    changeInputtingFindString(value: string): void;
+    changeReplaceString(value: string): void;
+    changeCaseSensitive(sensitive: boolean): void;
+    changeMatchesTheWholeCell(wholeCell: boolean): void;
+    changeFindScope(scope: FindScope): void;
+    changeFindDirection(direction: FindDirection): void;
+    changeFindBy(findBy: FindBy): void;
     moveToNextMatch(): void;
     moveToPreviousMatch(): void;
-    replace(): boolean;
-    replaceAll(): boolean;
+    replace(): Promise<boolean>;
+    replaceAll(): Promise<IReplaceAllResult>;
 }
 export declare const IFindReplaceService: import("@wendellhu/redi").IdentifierDecorator<IFindReplaceService>;
 /**
  * The find query object with finding options.
  */
-export interface IFindQuery {
-    text: string;
-    isRegex?: boolean;
-    ignoreCase?: boolean;
-    /** Other possible options set by business. */
-    [key: string]: boolean | string | number | undefined;
-}
-/**
- * This class stores find replace options state. These state are stored
- * here instead of the React component so we can change state from
- * operations.
- */
-export declare class FindReplaceState {
-    private readonly _stateUpdates$;
-    readonly stateUpdates$: Observable<Partial<IFindReplaceState>>;
-    private readonly _state$;
-    readonly state$: Observable<IFindReplaceState>;
-    get state(): IFindReplaceState;
-    private _findString;
-    private _revealed;
-    private _replaceRevealed;
-    private _matchesPosition;
-    private _matchesCount;
-    get findString(): string;
-    changeState(changes: Partial<IFindReplaceState>): void;
+export interface IFindQuery extends Pick<IFindReplaceState, 'replaceRevealed' | 'findString' | 'caseSensitive' | 'findBy' | 'findDirection' | 'findScope' | 'matchesTheWholeCell'> {
 }
 /**
  * This class stores find replace results and provides methods to perform replace or something.
+ *
+ * It **only** live through a find-replace session and would be disposed when the user
+ * close the find replace dialog (considered as session being terminated).
  */
 export declare class FindReplaceModel extends Disposable {
     private readonly _state;
     private readonly _providers;
-    private readonly _logService;
     private readonly _univerInstanceService;
-    private _matchPositionFindModel?;
+    private readonly _logService;
+    readonly currentMatch$: BehaviorSubject<Nullable<IFindMatch<unknown>>>;
+    readonly replaceables$: BehaviorSubject<IReplaceableMatch[]>;
+    /** All find models returned by providers. */
     private _findModels;
+    /** The find model that the current match is from. */
+    private _matchingModel;
     private _matches;
-    private _positionModel;
-    constructor(_state: FindReplaceState, _providers: Set<IFindReplaceProvider>, _logService: ILogService, _univerInstanceService: IUniverInstanceService);
-    find(): Promise<IFindComplete>;
+    private _currentSearchingDisposables;
+    get searched(): boolean;
+    constructor(_state: FindReplaceState, _providers: Set<IFindReplaceProvider>, _univerInstanceService: IUniverInstanceService, _logService: ILogService);
+    dispose(): void;
+    start(): Promise<IFindComplete>;
+    /** Call this method to start a `searching`. */
+    private _startSearching;
+    /** Terminate the current searching session, when searching string is empty. */
+    private _stopSearching;
+    private _subscribeToModelsChanges;
+    replace(): Promise<boolean>;
+    replaceAll(): Promise<IReplaceAllResult>;
+    getCurrentMatch(): Nullable<IFindMatch>;
     moveToNextMatch(): void;
     moveToPreviousMatch(): void;
     private _moveToInitialMatch;
-    private _cancelFinding;
+}
+export declare enum FindDirection {
+    /** Default. */
+    ROW = "row",
+    COLUMN = "column"
+}
+export declare enum FindBy {
+    VALUE = "value",
+    FORMULA = "formula"
+}
+export declare enum FindScope {
+    /** Default. */
+    SUBUNIT = "subunit",
+    /** Find the scope in the current unit. */
+    UNIT = "unit"
 }
 export interface IFindReplaceState {
     revealed: boolean;
     /** The string user inputs in the input box. */
     findString: string;
+    inputtingFindString: string;
     replaceString?: string;
     /** Indicates if is in replacing mode. */
     replaceRevealed: boolean;
     /** The currently focused match's index (1-based). */
     matchesPosition: number;
+    /** The number of all matches. */
     matchesCount: number;
+    /** Indicates if an user triggered finding process is progressed. */
+    findCompleted: boolean;
+    caseSensitive: boolean;
+    matchesTheWholeCell: boolean;
+    findDirection: FindDirection;
+    findScope: FindScope;
+    findBy: FindBy;
+}
+/**
+ * This class stores find replace options state. These state are stored
+ * here instead of the React component so we can change state from
+ * operations.
+ */
+export declare class FindReplaceState {
+    private readonly _stateUpdates$;
+    readonly stateUpdates$: Observable<Partial<IFindReplaceState>>;
+    private readonly _state$;
+    readonly state$: Observable<IFindReplaceState>;
+    get state(): IFindReplaceState;
+    private _findString;
+    private _inputtingFindString;
+    private _replaceString;
+    private _revealed;
+    private _replaceRevealed;
+    private _matchesPosition;
+    private _matchesCount;
+    private _caseSensitive;
+    private _matchesTheWholeCell;
+    private _findDirection;
+    private _findScope;
+    private _findBy;
+    private _findCompleted;
+    get inputtingFindString(): string;
+    get findString(): string;
+    get revealed(): boolean;
+    get replaceRevealed(): boolean;
+    get matchesPosition(): number;
+    get matchesCount(): number;
+    get replaceString(): string;
+    get caseSensitive(): boolean;
+    get matchesTheWholeCell(): boolean;
+    get findDirection(): FindDirection;
+    get findScope(): FindScope;
+    get findBy(): FindBy;
+    get findCompleted(): boolean;
+    changeState(changes: Partial<IFindReplaceState>): void;
 }
 export declare class FindReplaceService extends Disposable implements IFindReplaceService {
     private readonly _injector;
-    private readonly _univerInstanceService;
-    private readonly _logService;
+    private readonly _contextService;
     private readonly _providers;
     private readonly _state;
     private _model;
+    private readonly _currentMatch$;
+    readonly currentMatch$: Observable<Nullable<IFindMatch<unknown>>>;
+    private readonly _replaceables$;
+    readonly replaceables$: Observable<IReplaceableMatch[]>;
+    private readonly _focusSignal$;
+    readonly focusSignal$: Observable<void>;
     get stateUpdates$(): Observable<Partial<IFindReplaceState>>;
     get state$(): Observable<IFindReplaceState>;
-    constructor(_injector: Injector, _univerInstanceService: IUniverInstanceService, _logService: ILogService);
-    changeFindString(value: string): void;
+    get revealed(): boolean;
+    get replaceRevealed(): boolean;
+    constructor(_injector: Injector, _contextService: IContextService);
+    dispose(): void;
+    getCurrentMatch(): Nullable<IFindMatch>;
+    getFindString(): string;
+    changeFindString(findString: string): void;
+    focusFindInput(): void;
+    changeInputtingFindString(value: string): void;
+    changeReplaceString(replaceString: string): void;
+    changeMatchesTheWholeCell(matchesTheWholeCell: boolean): void;
+    changeCaseSensitive(caseSensitive: boolean): void;
+    changeFindBy(findBy: FindBy): void;
+    changeFindScope(scope: FindScope): void;
+    changeFindDirection(direction: FindDirection): void;
     moveToNextMatch(): void;
     moveToPreviousMatch(): void;
-    replace(): boolean;
-    replaceAll(): boolean;
+    replace(): Promise<boolean>;
+    replaceAll(): Promise<IReplaceAllResult>;
     revealReplace(): void;
-    disposeModel(): void;
-    start(): boolean;
-    end(): boolean;
+    start(revealReplace?: boolean): boolean;
+    find(): void;
+    terminate(): void;
     registerFindReplaceProvider(provider: IFindReplaceProvider): IDisposable;
+    private _toggleRevealReplace;
+    private _toggleDisplayRawFormula;
 }
+export {};

package/lib/types/views/dialog/FindReplaceDialog.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+import React from 'react';
+export declare const FindDialog: React.ForwardRefExoticComponent<React.RefAttributes<unknown>>;
+export declare const ReplaceDialog: React.ForwardRefExoticComponent<React.RefAttributes<unknown>>;
+export declare function FindReplaceDialog(): React.JSX.Element;

package/lib/types/views/dialog/SearchInput.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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.
+ */
+import type { LocaleService } from '@univerjs/core';
+import type { IInputWithSlotProps } from '@univerjs/design';
+import React from 'react';
+import type { IFindReplaceService } from '../../services/find-replace.service';
+export interface ISearchInputProps extends Pick<IInputWithSlotProps, 'onFocus' | 'onBlur' | 'className' | 'onChange'> {
+    findCompleted: boolean;
+    localeService: LocaleService;
+    findReplaceService: IFindReplaceService;
+    matchesPosition: number;
+    matchesCount: number;
+    findString: string;
+}
+export declare function SearchInput(props: ISearchInputProps): React.JSX.Element;