@univerjs/sheets-formula-ui 1.0.0-alpha.2 → 1.0.0-alpha.3

package/lib/types/index.d.ts

@@ -22,6 +22,7 @@ export { ReferenceAbsoluteOperation } from './commands/operations/reference-abso
 export { SearchFunctionOperation } from './commands/operations/search-function.operation';
 export type { IUniverSheetsFormulaUIConfig } from './config/config';
 export { FormulaReorderController } from './controllers/formula-reorder.controller';
+export { menuSchema as SheetsFormulaUIMenuSchema } from './menu/schema';
 export { UniverSheetsFormulaUIPlugin } from './plugin';
 export { FORMULA_PROMPT_ACTIVATED } from './services/prompt.service';
 export { GlobalRangeSelectorService } from './services/range-selector.service';

package/lib/types/views/formula-editor/formula-embed-integration.service.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Copyright 2023-present DreamNum Co., Ltd.
+ *
+ * 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 { IDisposable } from '@univerjs/core';
+export declare const FORMULA_EMBED_INTERACTION_BOUNDARY_OWNER_ATTRIBUTE = "data-embed-interaction-boundary-owner";
+export declare const FORMULA_EMBED_RUNTIME_FOCUS_ROLE_ATTRIBUTE = "data-embed-runtime-focus-role";
+export declare const FORMULA_EMBED_ID_ATTRIBUTE = "data-embed-id";
+export declare const FORMULA_EMBED_HOST_UNIT_ID_ATTRIBUTE = "data-embed-host-unit-id";
+export declare const FORMULA_EMBED_CHILD_UNIT_ID_ATTRIBUTE = "data-embed-child-unit-id";
+export interface IFormulaEmbedRuntimeDomScope {
+    embedId: string;
+    hostUnitId?: string;
+    childUnitId?: string;
+}
+export interface IFormulaEmbedRuntimeFocusCoordinator {
+    resolveRuntimeScopeByChildUnitId(childUnitId: string): IFormulaEmbedRuntimeDomScope | undefined;
+    acquireLease(options: {
+        embedId: string;
+        role: string;
+        owner: string;
+        hostUnitId?: string;
+        childUnitId?: string;
+        associatedChildUnitIds?: string[];
+    }): IDisposable;
+    registerElement(options: {
+        embedId: string;
+        role: string;
+        element: HTMLElement;
+    }): IDisposable;
+}
+export declare const IFormulaEmbedRuntimeFocusCoordinator: import("@wendellhu/redi").IdentifierDecorator<IFormulaEmbedRuntimeFocusCoordinator>;
+export interface IFormulaEmbedInteractionBoundaryService {
+    registerOwnedElement(embedId: string, element: Element): IDisposable;
+}
+export declare const IFormulaEmbedInteractionBoundaryService: import("@wendellhu/redi").IdentifierDecorator<IFormulaEmbedInteractionBoundaryService>;
+interface IRegisterFormulaEditorRuntimePortalOptions {
+    embedId: string;
+    editorId: string;
+    ownerDocument?: Document;
+    interactionBoundaryService?: IFormulaEmbedInteractionBoundaryService;
+    focusCoordinator?: IFormulaEmbedRuntimeFocusCoordinator;
+}
+export declare function registerFormulaEditorRuntimePortal(options: IRegisterFormulaEditorRuntimePortalOptions): IDisposable;
+export declare function resolveFormulaEmbedRuntimeDomScope(root: HTMLElement | null | undefined): IFormulaEmbedRuntimeDomScope | undefined;
+export declare function resolveActiveFormulaEmbedRuntimeDomScope(ownerDocument: Document | undefined): IFormulaEmbedRuntimeDomScope | undefined;
+export declare function isEventTargetInSameFormulaEmbedInteractionBoundary(left: EventTarget | null | undefined, right: EventTarget | null | undefined): boolean;
+export {};

package/lib/types/views/formula-editor/hooks/use-focus.d.ts

@@ -14,4 +14,15 @@
  * limitations under the License.
  */
 import type { Editor } from '@univerjs/docs-ui';
+import { IEditorService } from '@univerjs/docs-ui';
+export declare function focusFormulaEditor(editorService: Pick<IEditorService, 'focus'>, editor?: Pick<Editor, 'getEditorId' | 'getSelectionRanges' | 'setSelectionRanges' | 'getDocumentData' | 'docSelectionRenderService'> & {
+    editorDOM?: HTMLElement;
+}, offset?: number): void;
+export declare function shouldSkipFormulaEditorMouseUpFocus(_target: EventTarget | null): boolean;
+export declare function shouldRefocusFormulaEditorOnMouseUp(options: {
+    target: EventTarget | null;
+    isFocusing: boolean | undefined;
+    isPointerSelecting: boolean | undefined;
+}): boolean;
+export declare function hasActiveFormulaEmbedInteraction(scopeElement: HTMLElement | null | undefined): boolean;
 export declare const useFocus: (editor?: Editor) => (offset?: number) => void;

package/lib/types/views/formula-editor/hooks/use-formula-selection.d.ts

@@ -13,6 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import type { IAccessor } from '@univerjs/core';
+import type { Editor } from '@univerjs/docs-ui';
+export declare function resolveFormulaSelectionDataStream(accssor: IAccessor, editor?: Pick<Editor, 'getDocumentData'>, editorId?: string): {
+    dataStream: string;
+    offset: number;
+} | undefined;
 export declare enum FormulaSelectingType {
     NOT_SELECT = 0,
     NEED_ADD = 1,
@@ -21,7 +27,23 @@ export declare enum FormulaSelectingType {
     EDIT_OTHER_WORKBOOK_REFERENCE = 4
 }
 export declare function shouldSkipReferenceEditingByPointer(isDisabledByPointer: boolean, disableOnClick?: boolean): boolean;
+export declare function resolveFormulaSelectionWorkbook<TWorkbook>(currentWorkbook: TWorkbook | null | undefined, fallbackWorkbook: TWorkbook | null | undefined): TWorkbook | undefined;
+export declare function resolveFormulaSelectionCursorIndex(activeRange: {
+    collapsed?: boolean;
+    startOffset?: number;
+} | undefined, dataStream: string): number;
+export declare function getSelectionAfterLaggingFormulaInput(dataStream: string, selection: {
+    collapsed?: boolean;
+    startOffset?: number;
+    endOffset?: number;
+} | undefined, content: string): {
+    startOffset: number;
+    endOffset: number;
+    collapsed: true;
+} | undefined;
+export declare function resolveFormulaSelectingIntent(adding: boolean, editing: boolean): FormulaSelectingType;
 export declare function useFormulaSelecting(opts: {
+    editor?: Editor;
     editorId: string;
     isFocus: boolean;
     disableOnClick?: boolean;

package/lib/types/views/formula-editor/hooks/use-highlight.d.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { ITextRange, ITextRun, Workbook } from '@univerjs/core';
+import type { IDocumentBody, ITextRange, ITextRun, Workbook } from '@univerjs/core';
 import type { Editor } from '@univerjs/docs-ui';
 import type { ISequenceNode } from '@univerjs/engine-formula';
 import type { ISelectionWithStyle, SheetsSelectionsService } from '@univerjs/sheets';
@@ -47,8 +47,15 @@ export declare function calcHighlightRanges(opts: {
  * @param {string} subUnitId 打开面板的时候传入的 sheetId
  * @param {IRefSelection[]} refSelections
  */
-export declare function useSheetHighlight(unitId: string, subUnitId: string): (refSelections: IRefSelection[], editor?: Editor) => void;
-export declare function useDocHight(_leadingCharacter?: string): (editor: Editor, sequenceNodes: INode[], isNeedResetSelection?: any, newSelections?: ITextRange[]) => IRefSelection[];
+export declare function useSheetHighlight(unitId: string, subUnitId: string): (refSelections: IRefSelection[], editor?: Editor, isEnd?: any) => void;
+export declare function useDocHight(_leadingCharacter?: string): (editor: Editor, sequenceNodes: INode[], isNeedResetSelection?: any, newSelections?: ITextRange[], sourceText?: string) => IRefSelection[];
+/**
+ * ReplaceTextRunsCommand shifts the editor's existing structural metadata when text changes.
+ * Its replacement body must therefore contain only inline formula data; carrying paragraphs
+ * or section breaks copied from the old snapshot would leave their indexes stale.
+ */
+export declare function createFormulaHighlightBody(dataStream: string, textRuns: ITextRun[]): IDocumentBody;
+export declare function getFormulaHighlightDataStream(leadingCharacter: string, sequenceNodes: Array<ISequenceNode | string>, sourceText?: string): string;
 interface IColorMap {
     formulaRefColors: string[];
     numberColor: string;

package/lib/types/views/formula-editor/hooks/use-left-and-right-arrow.d.ts

@@ -16,4 +16,11 @@
 import type { Editor } from '@univerjs/docs-ui';
 import { KeyCode, MetaKeys } from '@univerjs/ui';
 import { FormulaSelectingType } from './use-formula-selection';
-export declare const useLeftAndRightArrow: (isNeed: boolean, shouldMoveSelection: FormulaSelectingType, editor?: Editor, onMoveInEditor?: (keyCode: KeyCode, metaKey?: MetaKeys) => void) => void;
+export declare function shouldMoveFormulaSelectionFromCurrentSelection(selectingType: FormulaSelectingType, refSelectionCount: number): boolean;
+export interface IFormulaEditorInteractionOwnerOptions {
+    fxBarFocused?: boolean;
+    formulaBarEditorId?: string;
+    normalEditorId?: string;
+}
+export declare function isFormulaEditorInteractionOwner(focusEditorId: string | null | undefined | void, editorId: string, options?: IFormulaEditorInteractionOwnerOptions): boolean;
+export declare const useLeftAndRightArrow: (isNeed: boolean, shouldMoveSelection: FormulaSelectingType, editor?: Editor, onMoveInEditor?: (keyCode: KeyCode, metaKey?: MetaKeys) => void, getRefSelectionCount?: () => number) => void;

package/lib/types/views/formula-editor/hooks/use-refactor-effect.d.ts

@@ -13,4 +13,4 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export declare const useRefactorEffect: (isNeed: boolean, selecting: boolean, unitId: string, editorId: string, disableContextMenu?: boolean) => void;
+export declare const useRefactorEffect: (isNeed: boolean, selecting: boolean | number, unitId: string, editorId: string, disableContextMenu?: boolean) => void;

package/lib/types/views/formula-editor/hooks/use-sheet-selection-change.d.ts

@@ -17,15 +17,48 @@ import type { IRange } from '@univerjs/core';
 import type { Editor } from '@univerjs/docs-ui';
 import type { RefObject } from 'react';
 import type { IRefSelection } from './use-highlight';
+import { LexerTreeBuilder } from '@univerjs/engine-formula';
 import { FormulaSelectingType } from './use-formula-selection';
+export declare const prepareSelectionChangeContext: (opts: {
+    editor?: Editor;
+    lexerTreeBuilder: LexerTreeBuilder;
+}) => {
+    nodeIndex: number;
+    updatingRefIndex: number;
+    formulaText: string;
+    sequenceNodes: (string | import("@univerjs/engine-formula").ISequenceNode)[];
+    offset: number;
+} | undefined;
+export declare function getSequenceNodeCharAtOffset(sequenceNodes: (string | {
+    token: string;
+})[], offset: number): string | undefined;
+export declare function isFormulaReferenceAddingContext(sequenceNodes: (string | {
+    token: string;
+})[], offset: number): boolean;
+export declare function isFormulaReferenceAddingTextContext(formulaText: string, offset: number): boolean;
+export declare function insertFormulaReferenceText(formulaText: string, refText: string, offset: number): string;
+export declare function shouldSkipFormulaReferenceUpdate(isAdd: boolean, selectionCount: number): boolean;
 export declare function getSelectionsForFormulaRefUpdate(selections: IRange[], updatingRefIndex: number, isCtrlAddMode?: boolean): {
     orderedSelections: IRange[];
     insertedSelection?: IRange;
 };
+export declare function getLastFormulaSelection(selections: IRange[]): IRange | undefined;
+export interface ISelectionChangeDuplicateEndGuard<TSelection> {
+    shouldSkip(selections: TSelection[], isEnd: boolean): boolean;
+    reset(): void;
+}
+export declare function getFormulaSelectionIdentityKey(selection: unknown): string;
+export declare function isSameFormulaSelection(first: unknown, second: unknown): boolean;
+export declare function getSharedSelectionChangeDuplicateEndGuard(key: string): ISelectionChangeDuplicateEndGuard<IRange>;
+export declare function createSelectionChangeDuplicateEndGuard<TSelection>(): ISelectionChangeDuplicateEndGuard<TSelection>;
 export declare function createSelectionChangeHandler<TSelection>(opts: {
     initialSelectionsCount: number;
     onSelectionsChange: (selections: TSelection[], isEnd: boolean, isCtrlAddMode?: boolean) => void;
+    onDuplicateEnd?: (selections: TSelection[]) => void;
+    duplicateEndGuard?: ISelectionChangeDuplicateEndGuard<TSelection>;
 }): (selections: TSelection[], isEnd: boolean, options?: {
     initial?: boolean;
 }) => void;
+export declare function replaceFormulaControlSelection(selections: IRange[], index: number, newRange: IRange): IRange[] | undefined;
+export declare function getInitialFormulaReferenceSelectionCount(renderSelectionCount: number, formulaReferenceCount: number, selectingType?: FormulaSelectingType): number;
 export declare const useSheetSelectionChange: (isNeed: boolean, isFocus: boolean, isSelectingRef: RefObject<FormulaSelectingType>, unitId: string, subUnitId: string, getRefSelections: () => IRefSelection[], isSupportAcrossSheet: boolean, listenSelectionSet: boolean, editor?: Editor, handleRangeChange?: ((refString: string, offset: number, isEnd: boolean, isModify?: boolean) => void)) => void;

package/lib/types/views/formula-editor/index.d.ts

@@ -54,9 +54,10 @@ export interface IFormulaEditorProps {
 export interface IFormulaEditorRef {
     isClickOutSide: (e: MouseEvent) => boolean;
 }
+export declare function shouldApplyFormulaSelectionChange(selectingMode: FormulaSelectingType | number, isFocusing: boolean | undefined, hasActiveInteraction: boolean): boolean;
 interface IFormulaEditorSelectionSyncService {
     getEditor: (editorId: string) => Pick<Editor, 'setSelectionRanges'> | null | undefined | void;
 }
 export declare function syncCounterpartFormulaEditorSelection(editorService: IFormulaEditorSelectionSyncService, editorId: string, selections: ITextRange[] | undefined): void;
+export { getSelectionAfterLaggingFormulaInput } from './hooks/use-formula-selection';
 export declare const FormulaEditor: import("react").ForwardRefExoticComponent<IFormulaEditorProps & import("react").RefAttributes<IFormulaEditorRef>>;
-export {};