@univerjs/sheets 0.20.1 → 0.21.0

package/lib/types/facade/permission/f-range-permission.d.ts

@@ -13,199 +13,54 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import type { Observable } from 'rxjs';
 import type { FRange } from '../f-range';
 import type { FWorksheet } from '../f-worksheet';
-import type { IRangeProtectionOptions, RangePermissionSnapshot } from './permission-types';
-import { IAuthzIoService, ICommandService, Injector, IPermissionService } from '@univerjs/core';
+import type { IRangeProtectionOptions } from './permission-types';
+import { IAuthzIoService, ICommandService, Injector } from '@univerjs/core';
+import { FBase } from '@univerjs/core/facade';
 import { RangeProtectionRuleModel } from '@univerjs/sheets';
 import { FRangeProtectionRule } from './f-range-protection-rule';
-import { RangePermissionPoint } from './permission-types';
 /**
  * Implementation class for RangePermission
  * Manages range-level permissions
  *
  * @hideconstructor
  */
-export declare class FRangePermission {
+export declare class FRangePermission extends FBase {
     private readonly _unitId;
     private readonly _subUnitId;
     private readonly _range;
     private readonly _worksheet;
     private readonly _injector;
-    private readonly _permissionService;
     private readonly _authzIoService;
     private readonly _commandService;
     private readonly _rangeProtectionRuleModel;
-    private readonly _permissionSubject;
-    private readonly _subscriptions;
-    private readonly _fPermission;
-    /**
-     * Observable stream of permission snapshot changes
-     * @returns Observable that emits when permission snapshot changes
-     */
-    readonly permission$: Observable<RangePermissionSnapshot>;
-    /**
-     * Observable stream of protection state changes
-     * @returns Observable that emits when protection state changes
-     */
-    readonly protectionChange$: Observable<{
-        type: 'protected';
-        rule: FRangeProtectionRule;
-    } | {
-        type: 'unprotected';
-        ruleId: string;
-    }>;
-    constructor(_unitId: string, _subUnitId: string, _range: FRange, _worksheet: FWorksheet, _injector: Injector, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel);
-    /**
-     * Create permission snapshot stream from IPermissionService
-     * @private
-     */
-    private _createPermissionStream;
-    /**
-     * Create protection change stream from RangeProtectionRuleModel
-     * @private
-     */
-    private _createProtectionChangeStream;
-    /**
-     * Check if a protection rule matches this range
-     */
-    private _rangeMatches;
-    /**
-     * Create a Facade rule from internal rule
-     */
-    private _createFacadeRule;
-    /**
-     * Get the value of a specific permission point.
-     * @param {RangePermissionPoint} point The permission point to query.
-     * @returns {boolean} true if allowed, false if denied.
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * const canEdit = permission?.getPoint(univerAPI.Enum.RangePermissionPoint.Edit);
-     * console.log(canEdit);
-     * ```
-     */
-    getPoint(point: RangePermissionPoint): boolean;
-    /**
-     * Get the current permission snapshot.
-     * @returns {RangePermissionSnapshot} Snapshot of all permission points.
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * const snapshot = permission?.getSnapshot();
-     * console.log(snapshot);
-     * ```
-     */
-    getSnapshot(): RangePermissionSnapshot;
+    constructor(_unitId: string, _subUnitId: string, _range: FRange, _worksheet: FWorksheet, _injector: Injector, _authzIoService: IAuthzIoService, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel);
     /**
      * Check if the current range is protected.
-     * @returns {boolean} true if protected, false otherwise.
+     * @returns {boolean} True if the range is protected, false otherwise.
      * @example
      * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * const isProtected = permission?.isProtected();
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const fRange = fWorksheet.getRange('A1:B2');
+     * // Check if the A1:B2 range is protected
+     * const isProtected = fRange.getRangePermission().isProtected();
      * console.log(isProtected);
      * ```
      */
     isProtected(): boolean;
-    /**
-     * Check if the current user can edit this range.
-     * @returns {boolean} true if editable, false otherwise.
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * if (permission?.canEdit()) {
-     *   console.log('You can edit this range');
-     * }
-     * ```
-     */
-    canEdit(): boolean;
-    /**
-     * Check if the current user can view this range.
-     * @returns {boolean} true if viewable, false otherwise.
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * if (permission?.canView()) {
-     *   console.log('You can view this range');
-     * }
-     * ```
-     */
-    canView(): boolean;
-    /**
-     * Check if the current user can manage collaborators for this range.
-     * @returns {boolean} true if can manage collaborators, false otherwise.
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * if (permission?.canManageCollaborator()) {
-     *   console.log('You can manage collaborators for this range');
-     * }
-     * ```
-     */
-    canManageCollaborator(): boolean;
-    /**
-     * Check if the current user can delete this protection rule.
-     * @returns {boolean} true if can delete rule, false otherwise.
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * if (permission?.canDelete()) {
-     *   console.log('You can delete this protection rule');
-     * }
-     * ```
-     */
-    canDelete(): boolean;
-    /**
-     * Set a specific permission point for the range (low-level API).
-     *
-     * **Important:** This method only updates the permission point value for an existing protection rule.
-     * It does NOT create permission checks that will block actual editing operations.
-     * You must call `protect()` first to create a protection rule before using this method.
-     *
-     * This method is useful for:
-     * - Fine-tuning permissions after creating a protection rule with `protect()`
-     * - Dynamically adjusting permissions based on runtime conditions
-     * - Advanced permission management scenarios
-     *
-     * @param {RangePermissionPoint} point The permission point to set.
-     * @param {boolean} value The value to set (true = allowed, false = denied).
-     * @returns {Promise<void>} A promise that resolves when the point is set.
-     * @throws {Error} If no protection rule exists for this range.
-     *
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     *
-     * // First, create a protection rule
-     * await permission?.protect({ name: 'My Range', allowEdit: true });
-     *
-     * // Then you can dynamically update permission points
-     * await permission?.setPoint(univerAPI.Enum.RangePermissionPoint.Edit, false); // Now disable edit
-     * await permission?.setPoint(univerAPI.Enum.RangePermissionPoint.View, true);  // Ensure view is enabled
-     * ```
-     */
-    setPoint(point: RangePermissionPoint, value: boolean): Promise<void>;
     /**
      * Protect the current range.
      * @param {IRangeProtectionOptions} options Protection options.
      * @returns {Promise<FRangeProtectionRule>} The created protection rule.
      * @example
      * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * const rule = await permission?.protect({
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const fRange = fWorksheet.getRange('A1:B2');
+     * const rule = await fRange.getRangePermission().protect({
      *   name: 'My protected range',
-     *   allowEdit: true,
      *   allowedUsers: ['user1', 'user2'],
      *   allowViewByOthers: false,
      * });
@@ -214,83 +69,31 @@ export declare class FRangePermission {
      */
     protect(options?: IRangeProtectionOptions): Promise<FRangeProtectionRule>;
     /**
-     * Determine view state from options
-     * @private
-     */
-    private _determineViewState;
-    /**
-     * Determine edit state from options
-     * @private
-     */
-    private _determineEditState;
-    /**
-     * Set permission points based on options (for local runtime control)
-     * @private
-     */
-    private _setPermissionPoints;
-    /**
-     * Set a single permission point
-     * @private
-     */
-    private _setPermissionPoint;
-    /**
-     * Unprotect the current range.
-     * @returns {Promise<void>} A promise that resolves when the range is unprotected.
+     * Cancel all protection rules that intersect with the current range.
+     * @returns {Promise<boolean>} True if all rules were successfully removed, false otherwise.
      * @example
      * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * await permission?.unprotect();
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const fRange = fWorksheet.getRange('A1:B2');
+     * const result = await fRange.getRangePermission().unprotect();
+     * console.log(result);
      * ```
      */
-    unprotect(): Promise<void>;
+    unprotect(): Promise<boolean>;
     /**
-     * List all protection rules.
+     * List all protection rules that intersect with the current range.
      * @returns {Promise<FRangeProtectionRule[]>} Array of protection rules.
      * @example
      * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * const rules = await permission?.listRules();
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const fRange = fWorksheet.getRange('A1:B2');
+     * const rules = await fRange.getRangePermission().listRules();
      * console.log(rules);
      * ```
      */
-    listRules(): Promise<FRangeProtectionRule[]>;
-    /**
-     * Subscribe to permission changes (simplified interface).
-     * @param {Function} listener Callback function to be called when permissions change.
-     * @returns {Function} Unsubscribe function.
-     * @example
-     * ```ts
-     * const range = univerAPI.getActiveWorkbook()?.getActiveSheet()?.getRange('A1:B2');
-     * const permission = range?.getRangePermission();
-     * const unsubscribe = permission?.subscribe((snapshot) => {
-     *   console.log('Permission changed:', snapshot);
-     * });
-     * // Later, to stop listening:
-     * unsubscribe?.();
-     * ```
-     */
-    subscribe(listener: (snapshot: RangePermissionSnapshot) => void): (() => void);
-    /**
-     * Get the protection rule for the current range
-     */
-    private _getProtectionRule;
-    /**
-     * Build Facade objects for all protection rules
-     */
-    private _buildProtectionRules;
-    /**
-     * Build Facade objects for all protection rules (async version with collaborator data)
-     * @private
-     */
-    private _buildProtectionRulesAsync;
-    /**
-     * Build permission snapshot
-     */
-    private _buildSnapshot;
-    /**
-     * Clean up resources
-     */
-    dispose(): void;
+    listRules(options?: {
+        ignoreCollaborators?: boolean;
+    }): Promise<FRangeProtectionRule[]>;
 }

package/lib/types/facade/permission/f-range-protection-rule.d.ts

@@ -14,9 +14,10 @@
  * limitations under the License.
  */
 import type { FRange } from '../f-range';
-import type { IRangeProtectionOptions } from './permission-types';
-import { ICommandService, Injector } from '@univerjs/core';
+import type { IRangeProtectionOptions, RangePermissionSnapshot } from './permission-types';
+import { IAuthzIoService, ICommandService, Injector, IPermissionService } from '@univerjs/core';
 import { RangeProtectionRuleModel } from '@univerjs/sheets';
+import { RangePermissionPoint } from './permission-types';
 /**
  * Implementation class for range protection rules
  * Encapsulates operations on a single protection rule
@@ -32,45 +33,24 @@ export declare class FRangeProtectionRule {
     private readonly _options;
     private readonly _injector;
     private readonly _commandService;
+    private readonly _permissionService;
+    private readonly _authzIoService;
     private readonly _rangeProtectionRuleModel;
-    constructor(_unitId: string, _subUnitId: string, _ruleId: string, _permissionId: string, _ranges: FRange[], _options: IRangeProtectionOptions, _injector: Injector, _commandService: ICommandService, _rangeProtectionRuleModel: RangeProtectionRuleModel);
+    constructor(_unitId: string, _subUnitId: string, _ruleId: string, _permissionId: string, _ranges: FRange[], _options: IRangeProtectionOptions, _injector: Injector, _commandService: ICommandService, _permissionService: IPermissionService, _authzIoService: IAuthzIoService, _rangeProtectionRuleModel: RangeProtectionRuleModel);
     /**
      * Get the rule ID.
-     * @returns {string} The unique identifier of this protection rule.
-     * @example
-     * ```ts
-     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
-     * const permission = worksheet?.getWorksheetPermission();
-     * const rules = await permission?.listRangeProtectionRules();
-     * const ruleId = rules?.[0]?.id;
-     * console.log(ruleId);
-     * ```
      */
     get id(): string;
+    /**
+     * Get the permission ID associated with this rule.
+     */
+    get permissionId(): string;
     /**
      * Get the protected ranges.
-     * @returns {FRange[]} Array of protected ranges.
-     * @example
-     * ```ts
-     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
-     * const permission = worksheet?.getWorksheetPermission();
-     * const rules = await permission?.listRangeProtectionRules();
-     * const ranges = rules?.[0]?.ranges;
-     * console.log(ranges);
-     * ```
      */
     get ranges(): FRange[];
     /**
      * Get the protection options.
-     * @returns {IRangeProtectionOptions} Copy of the protection options.
-     * @example
-     * ```ts
-     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
-     * const permission = worksheet?.getWorksheetPermission();
-     * const rules = await permission?.listRangeProtectionRules();
-     * const options = rules?.[0]?.options;
-     * console.log(options);
-     * ```
      */
     get options(): IRangeProtectionOptions;
     /**
@@ -79,31 +59,162 @@ export declare class FRangeProtectionRule {
      * @returns {Promise<void>} A promise that resolves when the ranges are updated.
      * @example
      * ```ts
-     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
-     * const permission = worksheet?.getWorksheetPermission();
-     * const rules = await permission?.listRangeProtectionRules();
-     * const rule = rules?.[0];
-     * await rule?.updateRanges([worksheet.getRange('A1:C3')]);
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Update the ranges to A1:C3 for the first rule
+     * if (rules.length > 0) {
+     *   const rule = rules[0];
+     *   const result = await rule.updateRanges([fWorksheet.getRange('A1:C3')]);
+     *   console.log(result);
+     * }
      * ```
      */
-    updateRanges(ranges: FRange[]): Promise<void>;
+    updateRanges(ranges: FRange[]): Promise<boolean>;
     /**
      * Delete the current protection rule.
      * @returns {Promise<void>} A promise that resolves when the rule is removed.
      * @example
      * ```ts
-     * const worksheet = univerAPI.getActiveWorkbook()?.getActiveSheet();
-     * const permission = worksheet?.getWorksheetPermission();
-     * const rules = await permission?.listRangeProtectionRules();
-     * const rule = rules?.[0];
-     * await rule?.remove();
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Remove the first protection rule
+     * if (rules.length > 0) {
+     *   const rule = rules[0];
+     *   const result = await rule.remove();
+     *   console.log(result);
+     * }
+     * ```
+     */
+    remove(): Promise<boolean>;
+    /**
+     * Set a specific permission point for the range rule (low-level API).
+     *
+     * **Important:** This method only updates the permission point value for an existing protection rule.
+     * It does NOT create permission checks that will block actual editing operations.
+     * You must call `protect()` first to create a protection rule before using this method.
+     *
+     * This method is useful for:
+     * - Fine-tuning permissions after creating a protection rule with `protect()`
+     * - Dynamically adjusting permissions based on runtime conditions
+     * - Advanced permission management scenarios
+     *
+     * @param {RangePermissionPoint} point The permission point to set.
+     * @param {boolean} value The value to set (true = allowed, false = denied).
+     * @returns {Promise<void>} A promise that resolves when the point is set.
+     * @throws {Error} If no protection rule exists for this range.
+     *
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const fRange = fWorksheet.getRange('A1:B2');
+     * // First, create a protection rule
+     * const rule = await fRange.getRangePermission().protect({ name: 'My Range', allowEdit: true });
+     * // Then you can dynamically update permission points
+     * await rule.setPoint(univerAPI.Enum.RangePermissionPoint.Edit, false); // Now disable edit
+     * await rule.setPoint(univerAPI.Enum.RangePermissionPoint.View, true);  // Ensure view is enabled
+     * ```
+     */
+    setPoint(point: RangePermissionPoint, value: boolean): Promise<void>;
+    /**
+     * Get the value of a specific permission point.
+     * @param {RangePermissionPoint} point The range permission point to query.
+     * @returns {boolean} true if allowed, false if denied.
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Check if the first rule allows editing
+     * if (rules.length > 0) {
+     *   const rule = rules[0];
+     *   const canEdit = rule.getPoint(univerAPI.Enum.RangePermissionPoint.Edit);
+     *   console.log(canEdit);
+     * }
+     * ```
+     */
+    getPoint(point: RangePermissionPoint): boolean;
+    /**
+     * Check if the current user can edit this range.
+     * @returns {boolean} true if editable, false otherwise.
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Check if the first rule allows editing
+     * const rule = rules[0];
+     * if (rule?.canEdit()) {
+     *   console.log(`You can edit this range ${rule.ranges.map(r => r.getA1Notation()).join(', ')}`);
+     * }
+     * ```
+     */
+    canEdit(): boolean;
+    /**
+     * Check if the current user can view this range.
+     * @returns {boolean} true if viewable, false otherwise.
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Check if the first rule allows viewing
+     * const rule = rules[0];
+     * if (rule?.canView()) {
+     *   console.log(`You can view this range ${rule.ranges.map(r => r.getA1Notation()).join(', ')}`);
+     * }
+     * ```
+     */
+    canView(): boolean;
+    /**
+     * Check if the current user can manage collaborators for this range.
+     * @returns {boolean} true if can manage collaborators, false otherwise.
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Check if the first rule allows managing collaborators
+     * const rule = rules[0];
+     * if (rule?.canManageCollaborator()) {
+     *   console.log(`You can manage collaborators for this range ${rule.ranges.map(r => r.getA1Notation()).join(', ')}`);
+     * }
      * ```
      */
-    remove(): Promise<void>;
+    canManageCollaborator(): boolean;
     /**
-     * Check if two ranges intersect
-     * @returns true if ranges intersect, false otherwise
-     * @private
+     * Check if the current user can delete this protection rule.
+     * @returns {boolean} true if can delete rule, false otherwise.
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Check if the first rule allows deleting the rule
+     * const rule = rules[0];
+     * if (rule?.canDelete()) {
+     *   console.log(`You can delete this protection rule for this range ${rule.ranges.map(r => r.getA1Notation()).join(', ')}`);
+     * }
+     * ```
+     */
+    canDelete(): boolean;
+    /**
+     * Get the current permission snapshot.
+     * @returns {RangePermissionSnapshot} Snapshot of all permission points.
+     * @example
+     * ```ts
+     * const fWorkbook = univerAPI.getActiveWorkbook();
+     * const fWorksheet = fWorkbook.getActiveSheet();
+     * const rules = await fWorksheet.getWorksheetPermission().listRangeProtectionRules();
+     * // Get the permission snapshot of the first rule
+     * if (rules.length > 0) {
+     *   const rule = rules[0];
+     *   const snapshot = rule.getSnapshot();
+     *   console.log(snapshot);
+     * }
+     * ```
      */
-    private _rangesIntersect;
+    getSnapshot(): RangePermissionSnapshot;
 }