ngx-dev-toolbar 1.0.4 → 2.0.0

package/tools/permissions-tool/permissions.service.d.ts

@@ -0,0 +1,87 @@
+import { Observable } from 'rxjs';
+import { DevToolsService } from '../../models/dev-tools.interface';
+import { DevToolbarPermission, ForcedPermissionsState } from './permissions.models';
+import * as i0 from "@angular/core";
+/**
+ * Public service for integrating the Permissions Tool with your application.
+ * Use this service to:
+ * 1. Register your application's permissions with setAvailableOptions()
+ * 2. Listen for toolbar permission overrides with getForcedValues()
+ * 3. Apply preset permission states for testing with applyPreset()
+ *
+ * @example
+ * ```typescript
+ * constructor(private permissionsService: DevToolbarPermissionsService) {
+ *   // Register permissions
+ *   this.permissionsService.setAvailableOptions([
+ *     { id: 'can-edit', name: 'Can Edit', isGranted: false, isForced: false }
+ *   ]);
+ *
+ *   // Listen for overrides
+ *   this.permissionsService.getForcedValues().subscribe(forcedPermissions => {
+ *     // Update your app's permission state
+ *   });
+ * }
+ * ```
+ */
+export declare class DevToolbarPermissionsService implements DevToolsService<DevToolbarPermission> {
+    private internalService;
+    /**
+     * Sets the available permissions that will be displayed in the toolbar tool.
+     * Call this in your app initialization to register permissions.
+     *
+     * @param permissions Array of permissions to display in the toolbar
+     *
+     * @example
+     * ```typescript
+     * this.permissionsService.setAvailableOptions([
+     *   {
+     *     id: 'can-edit-posts',
+     *     name: 'Edit Posts',
+     *     description: 'Can edit blog posts',
+     *     isGranted: false,
+     *     isForced: false
+     *   }
+     * ]);
+     * ```
+     */
+    setAvailableOptions(permissions: DevToolbarPermission[]): void;
+    /**
+     * Gets an observable of permissions that were forced/overridden through the toolbar.
+     * Subscribe to this to update your application's permission state.
+     *
+     * @returns Observable emitting array of forced permissions whenever changes occur
+     *
+     * @example
+     * ```typescript
+     * this.permissionsService.getForcedValues().subscribe(forcedPermissions => {
+     *   forcedPermissions.forEach(permission => {
+     *     this.updatePermission(permission.id, permission.isGranted);
+     *   });
+     * });
+     * ```
+     */
+    getForcedValues(): Observable<DevToolbarPermission[]>;
+    /**
+     * Apply a preset permission state. Useful for automated testing scenarios.
+     *
+     * @param state The forced permissions state to apply
+     *
+     * @example
+     * ```typescript
+     * this.permissionsService.applyPreset({
+     *   granted: ['can-edit-posts'],
+     *   denied: ['can-delete-posts']
+     * });
+     * ```
+     */
+    applyPreset(state: ForcedPermissionsState): void;
+    /**
+     * Get the current forced permission state.
+     *
+     * @returns Current forced permissions state
+     */
+    getCurrentState(): ForcedPermissionsState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarPermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarPermissionsService>;
+}

package/tools/presets-tool/presets-internal.service.d.ts

@@ -0,0 +1,57 @@
+import { Observable } from 'rxjs';
+import { DevToolbarPreset } from './presets.models';
+import * as i0 from "@angular/core";
+/**
+ * Internal service for managing presets state.
+ * Handles CRUD operations, captures current toolbar config, and applies presets.
+ */
+export declare class DevToolbarInternalPresetsService {
+    private readonly STORAGE_KEY;
+    private storageService;
+    private featureFlagsService;
+    private languageService;
+    private permissionsService;
+    private appFeaturesService;
+    private presetsSubject;
+    presets$: Observable<DevToolbarPreset[]>;
+    presets: import("@angular/core").Signal<DevToolbarPreset[]>;
+    constructor();
+    /**
+     * Capture current toolbar state as a new preset
+     */
+    saveCurrentAsPreset(name: string, description?: string): DevToolbarPreset;
+    /**
+     * Apply a preset to all tools (THIS IS THE KEY METHOD)
+     */
+    applyPreset(presetId: string): Promise<void>;
+    /**
+     * Update an existing preset with current toolbar state
+     */
+    updatePreset(presetId: string): void;
+    /**
+     * Delete a preset
+     */
+    deletePreset(presetId: string): void;
+    /**
+     * Add a preset (used for import)
+     */
+    addPreset(preset: DevToolbarPreset): DevToolbarPreset;
+    /**
+     * Get a preset by ID
+     */
+    getPresetById(presetId: string): DevToolbarPreset | undefined;
+    /**
+     * Capture current configuration from all tools
+     */
+    private captureCurrentConfig;
+    /**
+     * Load presets from localStorage
+     */
+    private loadPresets;
+    /**
+     * Generate unique preset ID
+     */
+    private generateId;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarInternalPresetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarInternalPresetsService>;
+}

package/tools/presets-tool/presets-tool.component.d.ts

@@ -0,0 +1,33 @@
+import { DevToolbarWindowOptions } from '../../components/toolbar-tool/toolbar-tool.models';
+import * as i0 from "@angular/core";
+export declare class DevToolbarPresetsToolComponent {
+    private readonly presetsService;
+    private readonly featureFlagsService;
+    private readonly permissionsService;
+    private readonly appFeaturesService;
+    private readonly languageService;
+    protected readonly viewMode: import("@angular/core").WritableSignal<"list" | "create">;
+    protected readonly searchQuery: import("@angular/core").WritableSignal<string>;
+    protected readonly presetName: import("@angular/core").WritableSignal<string>;
+    protected readonly presetDescription: import("@angular/core").WritableSignal<string>;
+    protected readonly presets: import("@angular/core").Signal<import("ngx-dev-toolbar").DevToolbarPreset[]>;
+    protected readonly filteredPresets: import("@angular/core").Signal<import("ngx-dev-toolbar").DevToolbarPreset[]>;
+    protected readonly hasNoPresets: import("@angular/core").Signal<boolean>;
+    protected readonly hasNoFilteredPresets: import("@angular/core").Signal<boolean>;
+    protected readonly options: DevToolbarWindowOptions;
+    onSearchChange(query: string): void;
+    onSwitchToCreateMode(): void;
+    onSwitchToListMode(): void;
+    onSavePreset(event: Event): void;
+    onApplyPreset(presetId: string): void;
+    onUpdatePreset(presetId: string): void;
+    onExportPreset(presetId: string): void;
+    onDeletePreset(presetId: string): void;
+    protected getCurrentFlagsCount(): number;
+    protected getCurrentPermissionsCount(): number;
+    protected getCurrentAppFeaturesCount(): number;
+    protected getCurrentLanguage(): string;
+    protected formatDate(isoString: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarPresetsToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DevToolbarPresetsToolComponent, "ndt-presets-tool", never, {}, {}, never, never, true, never>;
+}

package/tools/presets-tool/presets.models.d.ts

@@ -0,0 +1,24 @@
+export interface DevToolbarPreset {
+    id: string;
+    name: string;
+    description?: string;
+    createdAt: string;
+    updatedAt: string;
+    config: DevToolbarPresetConfig;
+}
+export interface DevToolbarPresetConfig {
+    featureFlags: {
+        enabled: string[];
+        disabled: string[];
+    };
+    language: string | null;
+    permissions: {
+        granted: string[];
+        denied: string[];
+    };
+    appFeatures: {
+        enabled: string[];
+        disabled: string[];
+    };
+}
+export type PresetFilter = 'all' | 'recent' | 'favorites';

package/tools/presets-tool/presets.service.d.ts

@@ -0,0 +1,51 @@
+import { Observable } from 'rxjs';
+import { DevToolbarPreset } from './presets.models';
+import * as i0 from "@angular/core";
+/**
+ * Public service for managing dev toolbar presets.
+ * Allows developers to programmatically save, load, and manage presets.
+ */
+export declare class DevToolbarPresetsService {
+    private internalService;
+    /**
+     * Get all saved presets as an Observable
+     */
+    getPresets(): Observable<DevToolbarPreset[]>;
+    /**
+     * Save current toolbar state as a preset
+     * @param name - Name for the preset
+     * @param description - Optional description
+     * @returns The created preset
+     */
+    savePreset(name: string, description?: string): DevToolbarPreset;
+    /**
+     * Apply a preset (load its configuration into all tools)
+     * @param presetId - ID of the preset to apply
+     */
+    applyPreset(presetId: string): Promise<void>;
+    /**
+     * Update a preset with current toolbar state
+     * @param presetId - ID of the preset to update
+     */
+    updatePreset(presetId: string): void;
+    /**
+     * Delete a preset
+     * @param presetId - ID of the preset to delete
+     */
+    deletePreset(presetId: string): void;
+    /**
+     * Export a preset as JSON string
+     * @param presetId - ID of the preset to export
+     * @returns JSON string representation of the preset
+     */
+    exportPreset(presetId: string): string | null;
+    /**
+     * Import a preset from JSON string
+     * @param json - JSON string representation of a preset
+     * @returns The imported preset
+     * @throws Error if JSON is invalid
+     */
+    importPreset(json: string): DevToolbarPreset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DevToolbarPresetsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DevToolbarPresetsService>;
+}