@stonecrop/stonecrop 0.4.37 → 0.5.0

package/dist/src/composables/operation-log.d.ts

@@ -0,0 +1,136 @@
+import type { HSTNode } from '../stores/hst';
+import type { OperationLogConfig } from '../types/operation-log';
+/**
+ * Composable for operation log management
+ * Provides easy access to undo/redo functionality and operation history
+ *
+ * @param config - Optional configuration for the operation log
+ * @returns Operation log interface
+ *
+ * @example
+ * ```typescript
+ * const { undo, redo, canUndo, canRedo, operations, configure } = useOperationLog()
+ *
+ * // Configure the log
+ * configure({
+ *   maxOperations: 50,
+ *   enableCrossTabSync: true,
+ *   enablePersistence: true
+ * })
+ *
+ * // Undo/redo
+ * await undo(hstStore)
+ * await redo(hstStore)
+ * ```
+ *
+ * @public
+ */
+export declare function useOperationLog(config?: Partial<OperationLogConfig>): {
+    operations: import("vue").Ref<{
+        id: string;
+        type: import("..").HSTOperationType;
+        path: string;
+        fieldname: string;
+        beforeValue: any;
+        afterValue: any;
+        doctype: string;
+        recordId?: string | undefined;
+        timestamp: Date;
+        source?: import("..").OperationSource | undefined;
+        reversible: boolean;
+        irreversibleReason?: string | undefined;
+        transition?: string | undefined;
+        currentState?: string | undefined;
+        targetState?: string | undefined;
+        actionName?: string | undefined;
+        actionRecordIds?: string[] | undefined;
+        actionResult?: "success" | "failure" | "pending" | undefined;
+        actionError?: string | undefined;
+        userId?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+        parentOperationId?: string | undefined;
+        childOperationIds?: string[] | undefined;
+    }[], import("..").HSTOperation[] | {
+        id: string;
+        type: import("..").HSTOperationType;
+        path: string;
+        fieldname: string;
+        beforeValue: any;
+        afterValue: any;
+        doctype: string;
+        recordId?: string | undefined;
+        timestamp: Date;
+        source?: import("..").OperationSource | undefined;
+        reversible: boolean;
+        irreversibleReason?: string | undefined;
+        transition?: string | undefined;
+        currentState?: string | undefined;
+        targetState?: string | undefined;
+        actionName?: string | undefined;
+        actionRecordIds?: string[] | undefined;
+        actionResult?: "success" | "failure" | "pending" | undefined;
+        actionError?: string | undefined;
+        userId?: string | undefined;
+        metadata?: Record<string, any> | undefined;
+        parentOperationId?: string | undefined;
+        childOperationIds?: string[] | undefined;
+    }[]>;
+    currentIndex: import("vue").Ref<number, number>;
+    undoRedoState: import("vue").ComputedRef<import("..").UndoRedoState>;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    undoCount: import("vue").ComputedRef<number>;
+    redoCount: import("vue").ComputedRef<number>;
+    undo: (hstStore: HSTNode) => boolean;
+    redo: (hstStore: HSTNode) => boolean;
+    startBatch: () => void;
+    commitBatch: (description?: string) => string | null;
+    cancelBatch: () => void;
+    clear: () => void;
+    getOperationsFor: (doctype: string, recordId?: string) => import("..").HSTOperation[];
+    getSnapshot: () => import("..").OperationLogSnapshot;
+    markIrreversible: (operationId: string, reason: string) => void;
+    logAction: (doctype: string, actionName: string, recordIds?: string[], result?: "success" | "failure" | "pending", error?: string) => string;
+    configure: (options: Partial<OperationLogConfig>) => void;
+};
+/**
+ * Keyboard shortcut handler for undo/redo
+ * Automatically binds Ctrl+Z (undo) and Ctrl+Shift+Z/Ctrl+Y (redo) using VueUse
+ *
+ * @param hstStore - The HST store to operate on
+ * @param enabled - Whether shortcuts are enabled (default: true)
+ *
+ * @example
+ * ```typescript
+ * import { onMounted } from 'vue'
+ *
+ * const stonecrop = useStonecrop({ doctype, recordId })
+ * useUndoRedoShortcuts(stonecrop.hstStore)
+ * ```
+ *
+ * @public
+ */
+export declare function useUndoRedoShortcuts(hstStore: HSTNode, enabled?: boolean): void;
+/**
+ * Batch operation helper
+ * Wraps a function execution in a batch operation
+ *
+ * @param fn - The function to execute within a batch
+ * @param description - Optional description for the batch
+ * @returns The batch operation ID
+ *
+ * @example
+ * ```typescript
+ * const { withBatch } = useOperationLog()
+ *
+ * const batchId = await withBatch(() => {
+ *   hstStore.set('task.123.title', 'New Title')
+ *   hstStore.set('task.123.status', 'active')
+ *   hstStore.set('task.123.priority', 'high')
+ * }, 'Update task details')
+ * ```
+ *
+ * @public
+ */
+export declare function withBatch<T>(fn: () => T | Promise<T>, description?: string): Promise<string | null>;
+//# sourceMappingURL=operation-log.d.ts.map

package/dist/src/composables/operation-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation-log.d.ts","sourceRoot":"","sources":["../../../src/composables/operation-log.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAE5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,eAAe,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,kBAAkB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAiB3C,OAAO,KAAG,OAAO;qBAOjB,OAAO,KAAG,OAAO;;gCAcN,MAAM,KAAG,MAAM,GAAG,IAAI;;;gCAqBtB,MAAM,aAAa,MAAM;;oCAgBrB,MAAM,UAAU,MAAM;yBAcnD,MAAM,cACH,MAAM,cACN,MAAM,EAAE,WACZ,SAAS,GAAG,SAAS,GAAG,SAAS,UACjC,MAAM,KACZ,MAAM;yBAQmB,OAAO,CAAC,kBAAkB,CAAC;EA2BvD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,OAAO,EAAE,OAAO,UAAO,QAqCrE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAYzG"}

package/dist/src/composables/operation-log.js

@@ -0,0 +1,221 @@
+import { useMagicKeys, whenever } from '@vueuse/core';
+import { storeToRefs } from 'pinia';
+import { inject } from 'vue';
+import { useOperationLogStore } from '../stores/operation-log';
+/**
+ * Composable for operation log management
+ * Provides easy access to undo/redo functionality and operation history
+ *
+ * @param config - Optional configuration for the operation log
+ * @returns Operation log interface
+ *
+ * @example
+ * ```typescript
+ * const { undo, redo, canUndo, canRedo, operations, configure } = useOperationLog()
+ *
+ * // Configure the log
+ * configure({
+ *   maxOperations: 50,
+ *   enableCrossTabSync: true,
+ *   enablePersistence: true
+ * })
+ *
+ * // Undo/redo
+ * await undo(hstStore)
+ * await redo(hstStore)
+ * ```
+ *
+ * @public
+ */
+export function useOperationLog(config) {
+    // Try to use the injected store from the Stonecrop plugin first
+    // This ensures we use the same Pinia instance as the app
+    const injectedStore = inject('$operationLogStore', undefined);
+    const store = injectedStore || useOperationLogStore();
+    // Apply configuration if provided
+    if (config) {
+        store.configure(config);
+    }
+    // Extract reactive state
+    const { operations, currentIndex, undoRedoState, canUndo, canRedo, undoCount, redoCount } = storeToRefs(store);
+    /**
+     * Undo the last operation
+     */
+    function undo(hstStore) {
+        return store.undo(hstStore);
+    }
+    /**
+     * Redo the next operation
+     */
+    function redo(hstStore) {
+        return store.redo(hstStore);
+    }
+    /**
+     * Start a batch operation
+     */
+    function startBatch() {
+        store.startBatch();
+    }
+    /**
+     * Commit the current batch
+     */
+    function commitBatch(description) {
+        return store.commitBatch(description);
+    }
+    /**
+     * Cancel the current batch
+     */
+    function cancelBatch() {
+        store.cancelBatch();
+    }
+    /**
+     * Clear all operations
+     */
+    function clear() {
+        store.clear();
+    }
+    /**
+     * Get operations for a specific doctype/record
+     */
+    function getOperationsFor(doctype, recordId) {
+        return store.getOperationsFor(doctype, recordId);
+    }
+    /**
+     * Get a snapshot of the operation log
+     */
+    function getSnapshot() {
+        return store.getSnapshot();
+    }
+    /**
+     * Mark an operation as irreversible
+     * @param operationId - The ID of the operation to mark
+     * @param reason - The reason why the operation is irreversible
+     */
+    function markIrreversible(operationId, reason) {
+        store.markIrreversible(operationId, reason);
+    }
+    /**
+     * Log an action execution (stateless actions like print, email, etc.)
+     * @param doctype - The doctype the action was executed on
+     * @param actionName - The name of the action that was executed
+     * @param recordIds - Optional array of record IDs the action was executed on
+     * @param result - The result of the action execution
+     * @param error - Optional error message if action failed
+     * @returns The operation ID
+     */
+    function logAction(doctype, actionName, recordIds, result = 'success', error) {
+        return store.logAction(doctype, actionName, recordIds, result, error);
+    }
+    /**
+     * Update configuration
+     * @param options - Configuration options to update
+     */
+    function configure(options) {
+        store.configure(options);
+    }
+    return {
+        // State
+        operations,
+        currentIndex,
+        undoRedoState,
+        canUndo,
+        canRedo,
+        undoCount,
+        redoCount,
+        // Methods
+        undo,
+        redo,
+        startBatch,
+        commitBatch,
+        cancelBatch,
+        clear,
+        getOperationsFor,
+        getSnapshot,
+        markIrreversible,
+        logAction,
+        configure,
+    };
+}
+/**
+ * Keyboard shortcut handler for undo/redo
+ * Automatically binds Ctrl+Z (undo) and Ctrl+Shift+Z/Ctrl+Y (redo) using VueUse
+ *
+ * @param hstStore - The HST store to operate on
+ * @param enabled - Whether shortcuts are enabled (default: true)
+ *
+ * @example
+ * ```typescript
+ * import { onMounted } from 'vue'
+ *
+ * const stonecrop = useStonecrop({ doctype, recordId })
+ * useUndoRedoShortcuts(stonecrop.hstStore)
+ * ```
+ *
+ * @public
+ */
+export function useUndoRedoShortcuts(hstStore, enabled = true) {
+    if (!enabled)
+        return;
+    const { undo, redo, canUndo, canRedo } = useOperationLog();
+    const keys = useMagicKeys();
+    // Undo shortcuts: Ctrl+Z or Cmd+Z (Mac)
+    whenever(keys['Ctrl+Z'], () => {
+        if (canUndo.value) {
+            undo(hstStore);
+        }
+    });
+    whenever(keys['Meta+Z'], () => {
+        if (canUndo.value) {
+            undo(hstStore);
+        }
+    });
+    // Redo shortcuts: Ctrl+Shift+Z, Cmd+Shift+Z (Mac), or Ctrl+Y
+    whenever(keys['Ctrl+Shift+Z'], () => {
+        if (canRedo.value) {
+            redo(hstStore);
+        }
+    });
+    whenever(keys['Meta+Shift+Z'], () => {
+        if (canRedo.value) {
+            redo(hstStore);
+        }
+    });
+    whenever(keys['Ctrl+Y'], () => {
+        if (canRedo.value) {
+            redo(hstStore);
+        }
+    });
+}
+/**
+ * Batch operation helper
+ * Wraps a function execution in a batch operation
+ *
+ * @param fn - The function to execute within a batch
+ * @param description - Optional description for the batch
+ * @returns The batch operation ID
+ *
+ * @example
+ * ```typescript
+ * const { withBatch } = useOperationLog()
+ *
+ * const batchId = await withBatch(() => {
+ *   hstStore.set('task.123.title', 'New Title')
+ *   hstStore.set('task.123.status', 'active')
+ *   hstStore.set('task.123.priority', 'high')
+ * }, 'Update task details')
+ * ```
+ *
+ * @public
+ */
+export async function withBatch(fn, description) {
+    const { startBatch, commitBatch, cancelBatch } = useOperationLog();
+    startBatch();
+    try {
+        await fn();
+        return commitBatch(description);
+    }
+    catch (error) {
+        cancelBatch();
+        throw error;
+    }
+}

package/dist/src/doctype.d.ts

@@ -24,7 +24,7 @@ export default class DoctypeMeta {
      */
     readonly workflow: ImmutableDoctype['workflow'];
     /**
-     * The doctype actions
+     * The doctype actions and field triggers
      * @public
      * @readonly
      */
@@ -35,6 +35,14 @@ export default class DoctypeMeta {
      * @readonly
      */
     readonly component?: Component;
+    /**
+     * Creates a new DoctypeMeta instance
+     * @param doctype - The doctype name
+     * @param schema - The doctype schema definition
+     * @param workflow - The doctype workflow configuration (XState machine)
+     * @param actions - The doctype actions and field triggers
+     * @param component - Optional Vue component for rendering the doctype
+     */
     constructor(doctype: string, schema: ImmutableDoctype['schema'], workflow: ImmutableDoctype['workflow'], actions: ImmutableDoctype['actions'], component?: Component);
     /**
      * Converts the registered doctype string to a slug (kebab-case). The following conversions are made:

package/dist/src/doctype.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doctype.d.ts","sourceRoot":"","sources":["../../src/doctype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,WAAW;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IAE3C;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAA;IAE/C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAA;IAE7C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAA;gBAK7B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAClC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,EACtC,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,EACpC,SAAS,CAAC,EAAE,SAAS;IAStB;;;;;;;;;;;;;;;OAeG;IACH,IAAI,IAAI,WAKP;CACD"}
+{"version":3,"file":"doctype.d.ts","sourceRoot":"","sources":["../../src/doctype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAE/C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,WAAW;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IAExB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAA;IAE3C;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,CAAA;IAE/C;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,CAAA;IAE7C;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAA;IAE9B;;;;;;;OAOG;gBAEF,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,gBAAgB,CAAC,QAAQ,CAAC,EAClC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,EACtC,OAAO,EAAE,gBAAgB,CAAC,SAAS,CAAC,EACpC,SAAS,CAAC,EAAE,SAAS;IAStB;;;;;;;;;;;;;;;OAeG;IACH,IAAI,IAAI,WAKP;CACD"}

package/dist/{doctype.js → src/doctype.js}

@@ -22,7 +22,7 @@ export default class DoctypeMeta {
      */
     workflow;
     /**
-     * The doctype actions
+     * The doctype actions and field triggers
      * @public
      * @readonly
      */
@@ -33,8 +33,14 @@ export default class DoctypeMeta {
      * @readonly
      */
     component;
-    // TODO: allow different components for different views; probably
-    // should be defined in the schema instead?
+    /**
+     * Creates a new DoctypeMeta instance
+     * @param doctype - The doctype name
+     * @param schema - The doctype schema definition
+     * @param workflow - The doctype workflow configuration (XState machine)
+     * @param actions - The doctype actions and field triggers
+     * @param component - Optional Vue component for rendering the doctype
+     */
     constructor(doctype, schema, workflow, actions, component) {
         this.doctype = doctype;
         this.schema = schema;

package/dist/src/field-triggers.d.ts

@@ -0,0 +1,178 @@
+import type { Map as ImmutableMap } from 'immutable';
+import type { FieldActionFunction, FieldChangeContext, FieldTriggerExecutionResult, FieldTriggerOptions, TransitionChangeContext, TransitionActionFunction, TransitionExecutionResult } from './types/field-triggers';
+/**
+ * Field trigger execution engine integrated with Registry
+ * Singleton pattern following Registry implementation
+ * @public
+ */
+export declare class FieldTriggerEngine {
+    /**
+     * The root FieldTriggerEngine instance
+     */
+    static _root: FieldTriggerEngine;
+    private options;
+    private doctypeActions;
+    private doctypeTransitions;
+    private fieldRollbackConfig;
+    private globalActions;
+    private globalTransitionActions;
+    /**
+     * Creates a new FieldTriggerEngine instance (singleton pattern)
+     * @param options - Configuration options for the field trigger engine
+     */
+    constructor(options?: FieldTriggerOptions);
+    /**
+     * Register a global action function
+     * @param name - The name of the action
+     * @param fn - The action function
+     */
+    registerAction(name: string, fn: FieldActionFunction): void;
+    /**
+     * Register a global XState transition action function
+     * @param name - The name of the transition action
+     * @param fn - The transition action function
+     */
+    registerTransitionAction(name: string, fn: TransitionActionFunction): void;
+    /**
+     * Configure rollback behavior for a specific field trigger
+     * @param doctype - The doctype name
+     * @param fieldname - The field name
+     * @param enableRollback - Whether to enable rollback
+     */
+    setFieldRollback(doctype: string, fieldname: string, enableRollback: boolean): void;
+    /**
+     * Get rollback configuration for a specific field trigger
+     */
+    private getFieldRollback;
+    /**
+     * Register actions from a doctype - both regular actions and field triggers
+     * Separates XState transitions (uppercase) from field triggers (lowercase)
+     * @param doctype - The doctype name
+     * @param actions - The actions to register (supports Immutable Map, Map, or plain object)
+     */
+    registerDoctypeActions(doctype: string, actions: ImmutableMap<string, string[]> | Map<string, string[]> | Record<string, string[]> | undefined): void;
+    /**
+     * Categorize an action as either a field trigger or XState transition
+     * Uses uppercase convention: UPPERCASE = transition, lowercase/mixed = field trigger
+     */
+    private categorizeAction;
+    /**
+     * Determine if a key represents an XState transition
+     * Transitions are identified by being all uppercase
+     */
+    private isTransitionKey;
+    /**
+     * Execute field triggers for a changed field
+     * @param context - The field change context
+     * @param options - Execution options (timeout and enableRollback)
+     */
+    executeFieldTriggers(context: FieldChangeContext, options?: {
+        timeout?: number;
+        enableRollback?: boolean;
+    }): Promise<FieldTriggerExecutionResult>;
+    /**
+     * Execute XState transition actions
+     * Similar to field triggers but specifically for FSM state transitions
+     * @param context - The transition change context
+     * @param options - Execution options (timeout)
+     */
+    executeTransitionActions(context: TransitionChangeContext, options?: {
+        timeout?: number;
+    }): Promise<TransitionExecutionResult[]>;
+    /**
+     * Find transition actions for a specific doctype and transition
+     */
+    private findTransitionActions;
+    /**
+     * Execute a single transition action by name
+     */
+    private executeTransitionAction;
+    /**
+     * Find field triggers for a specific doctype and field
+     * Field triggers are identified by keys that look like field paths (contain dots or match field names)
+     */
+    private findFieldTriggers;
+    /**
+     * Determine if an action key represents a field trigger
+     * Field triggers can be:
+     * - Exact field name match: "emailAddress"
+     * - Wildcard patterns: "emailAddress.*", "*.is_primary"
+     * - Nested field paths: "address.street", "contact.email"
+     */
+    private isFieldTriggerKey;
+    /**
+     * Match a field pattern against a field name
+     * Supports wildcards (*) for dynamic segments
+     */
+    private matchFieldPattern;
+    /**
+     * Execute a single action by name
+     */
+    private executeAction;
+    /**
+     * Execute a function with timeout
+     */
+    private executeWithTimeout;
+    /**
+     * Capture a snapshot of the record state before executing actions
+     * This creates a deep copy of the record data for potential rollback
+     */
+    private captureSnapshot;
+    /**
+     * Restore a previously captured snapshot
+     * This reverts the record to its state before actions were executed
+     */
+    private restoreSnapshot;
+}
+/**
+ * Get or create the global field trigger engine singleton
+ * @param options - Optional configuration for the field trigger engine
+ * @public
+ */
+export declare function getGlobalTriggerEngine(options?: FieldTriggerOptions): FieldTriggerEngine;
+/**
+ * Register a global action function that can be used in field triggers
+ * @param name - The name of the action to register
+ * @param fn - The action function to execute when the trigger fires
+ * @public
+ */
+export declare function registerGlobalAction(name: string, fn: FieldActionFunction): void;
+/**
+ * Register a global XState transition action function
+ * @param name - The name of the transition action to register
+ * @param fn - The transition action function to execute
+ * @public
+ */
+export declare function registerTransitionAction(name: string, fn: TransitionActionFunction): void;
+/**
+ * Configure rollback behavior for a specific field trigger
+ * @param doctype - The doctype name
+ * @param fieldname - The field name
+ * @param enableRollback - Whether to enable automatic rollback for this field
+ * @public
+ */
+export declare function setFieldRollback(doctype: string, fieldname: string, enableRollback: boolean): void;
+/**
+ * Manually trigger an XState transition for a specific doctype/record
+ * This can be called directly when you need to execute transition actions programmatically
+ * @param doctype - The doctype name
+ * @param transition - The XState transition name to trigger
+ * @param options - Optional configuration for the transition
+ * @public
+ */
+export declare function triggerTransition(doctype: string, transition: string, options?: {
+    recordId?: string;
+    currentState?: string;
+    targetState?: string;
+    fsmContext?: Record<string, any>;
+    path?: string;
+}): Promise<any>;
+/**
+ * Mark a specific operation as irreversible.
+ * Used to prevent undo of critical operations like publishing or deletion.
+ * @param operationId - The ID of the operation to mark as irreversible
+ * @param reason - Human-readable reason why the operation cannot be undone
+ * @public
+ */
+export declare function markOperationIrreversible(operationId: string | undefined, reason: string): void;
+//# sourceMappingURL=field-triggers.d.ts.map

package/dist/src/field-triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-triggers.d.ts","sourceRoot":"","sources":["../../src/field-triggers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,IAAI,YAAY,EAAE,MAAM,WAAW,CAAA;AAEpD,OAAO,KAAK,EACX,mBAAmB,EACnB,kBAAkB,EAClB,2BAA2B,EAC3B,mBAAmB,EAEnB,uBAAuB,EACvB,wBAAwB,EACxB,yBAAyB,EACzB,MAAM,wBAAwB,CAAA;AAE/B;;;;GAIG;AACH,qBAAa,kBAAkB;IAC9B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,kBAAkB,CAAA;IAEhC,OAAO,CAAC,OAAO,CAA2F;IAC1G,OAAO,CAAC,cAAc,CAA2C;IACjE,OAAO,CAAC,kBAAkB,CAA2C;IACrE,OAAO,CAAC,mBAAmB,CAA0C;IACrE,OAAO,CAAC,aAAa,CAAyC;IAC9D,OAAO,CAAC,uBAAuB,CAA8C;IAE7E;;;OAGG;gBACS,OAAO,GAAE,mBAAwB;IAa7C;;;;OAIG;IACH,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,mBAAmB,GAAG,IAAI;IAI3D;;;;OAIG;IACH,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,wBAAwB,GAAG,IAAI;IAI1E;;;;;OAKG;IACH,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,IAAI;IAOnF;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;;OAKG;IACH,sBAAsB,CACrB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,SAAS,GACpG,IAAI;IA+BP;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAKvB;;;;OAIG;IACG,oBAAoB,CACzB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,cAAc,CAAC,EAAE,OAAO,CAAA;KAAO,GAC1D,OAAO,CAAC,2BAA2B,CAAC;IA6FvC;;;;;OAKG;IACG,wBAAwB,CAC7B,OAAO,EAAE,uBAAuB,EAChC,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO,GAChC,OAAO,CAAC,yBAAyB,EAAE,CAAC;IAmDvC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;YACW,uBAAuB;IAiDrC;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAgBzB;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAiBzB;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IAwBzB;;OAEG;YACW,aAAa;IAoC3B;;OAEG;YACW,kBAAkB;IAsBhC;;;OAGG;IACH,OAAO,CAAC,eAAe;IA2BvB;;;OAGG;IACH,OAAO,CAAC,eAAe;CAsBvB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,kBAAkB,CAExF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,mBAAmB,GAAG,IAAI,CAGhF;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,wBAAwB,GAAG,IAAI,CAGzF;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,IAAI,CAGlG;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACtC,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;IACT,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACb,GACC,OAAO,CAAC,GAAG,CAAC,CAmBd;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAS/F"}