@stonecrop/stonecrop 0.4.36 → 0.5.0

package/dist/src/field-triggers.js

@@ -0,0 +1,564 @@
+import { useOperationLogStore } from './stores/operation-log';
+/**
+ * Field trigger execution engine integrated with Registry
+ * Singleton pattern following Registry implementation
+ * @public
+ */
+export class FieldTriggerEngine {
+    /**
+     * The root FieldTriggerEngine instance
+     */
+    static _root;
+    options;
+    doctypeActions = new Map(); // doctype -> action/field -> functions
+    doctypeTransitions = new Map(); // doctype -> transition -> functions
+    fieldRollbackConfig = new Map(); // doctype -> field -> rollback enabled
+    globalActions = new Map(); // action name -> function
+    globalTransitionActions = new Map(); // transition action name -> function
+    /**
+     * Creates a new FieldTriggerEngine instance (singleton pattern)
+     * @param options - Configuration options for the field trigger engine
+     */
+    constructor(options = {}) {
+        if (FieldTriggerEngine._root) {
+            return FieldTriggerEngine._root;
+        }
+        FieldTriggerEngine._root = this;
+        this.options = {
+            defaultTimeout: options.defaultTimeout ?? 5000,
+            debug: options.debug ?? false,
+            enableRollback: options.enableRollback ?? true,
+            errorHandler: options.errorHandler,
+        };
+    }
+    /**
+     * Register a global action function
+     * @param name - The name of the action
+     * @param fn - The action function
+     */
+    registerAction(name, fn) {
+        this.globalActions.set(name, fn);
+    }
+    /**
+     * Register a global XState transition action function
+     * @param name - The name of the transition action
+     * @param fn - The transition action function
+     */
+    registerTransitionAction(name, fn) {
+        this.globalTransitionActions.set(name, fn);
+    }
+    /**
+     * 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, fieldname, enableRollback) {
+        if (!this.fieldRollbackConfig.has(doctype)) {
+            this.fieldRollbackConfig.set(doctype, new Map());
+        }
+        this.fieldRollbackConfig.get(doctype).set(fieldname, enableRollback);
+    }
+    /**
+     * Get rollback configuration for a specific field trigger
+     */
+    getFieldRollback(doctype, fieldname) {
+        return this.fieldRollbackConfig.get(doctype)?.get(fieldname);
+    }
+    /**
+     * 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, actions) {
+        if (!actions)
+            return;
+        const actionMap = new Map();
+        const transitionMap = new Map();
+        // Convert from different Map types to regular Map
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (typeof actions.entrySeq === 'function') {
+            // Immutable Map
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            ;
+            actions.entrySeq().forEach(([key, value]) => {
+                this.categorizeAction(key, value, actionMap, transitionMap);
+            });
+        }
+        else if (actions instanceof Map) {
+            // Regular Map
+            for (const [key, value] of actions) {
+                this.categorizeAction(key, value, actionMap, transitionMap);
+            }
+        }
+        else if (actions && typeof actions === 'object') {
+            // Plain object
+            Object.entries(actions).forEach(([key, value]) => {
+                this.categorizeAction(key, value, actionMap, transitionMap);
+            });
+        }
+        // Always set the maps, even if empty
+        this.doctypeActions.set(doctype, actionMap);
+        this.doctypeTransitions.set(doctype, transitionMap);
+    }
+    /**
+     * Categorize an action as either a field trigger or XState transition
+     * Uses uppercase convention: UPPERCASE = transition, lowercase/mixed = field trigger
+     */
+    categorizeAction(key, value, actionMap, transitionMap) {
+        // Check if the key is all uppercase (XState transition convention)
+        if (this.isTransitionKey(key)) {
+            transitionMap.set(key, value);
+        }
+        else {
+            actionMap.set(key, value);
+        }
+    }
+    /**
+     * Determine if a key represents an XState transition
+     * Transitions are identified by being all uppercase
+     */
+    isTransitionKey(key) {
+        // Must be all uppercase letters/numbers/underscores
+        return /^[A-Z0-9_]+$/.test(key) && key.length > 0;
+    }
+    /**
+     * Execute field triggers for a changed field
+     * @param context - The field change context
+     * @param options - Execution options (timeout and enableRollback)
+     */
+    async executeFieldTriggers(context, options = {}) {
+        const { doctype, fieldname } = context;
+        const triggers = this.findFieldTriggers(doctype, fieldname);
+        if (triggers.length === 0) {
+            return {
+                path: context.path,
+                actionResults: [],
+                totalExecutionTime: 0,
+                allSucceeded: true,
+                stoppedOnError: false,
+                rolledBack: false,
+            };
+        }
+        const startTime = performance.now();
+        const actionResults = [];
+        let stoppedOnError = false;
+        let rolledBack = false;
+        let snapshot = undefined;
+        // Determine if rollback is enabled (priority: execution option > field config > global setting)
+        const fieldRollbackConfig = this.getFieldRollback(doctype, fieldname);
+        const rollbackEnabled = options.enableRollback ?? fieldRollbackConfig ?? this.options.enableRollback;
+        // Capture snapshot before executing actions if rollback is enabled
+        if (rollbackEnabled && context.store) {
+            snapshot = this.captureSnapshot(context);
+        }
+        // Execute actions sequentially
+        for (const actionName of triggers) {
+            try {
+                const actionResult = await this.executeAction(actionName, context, options.timeout);
+                actionResults.push(actionResult);
+                if (!actionResult.success) {
+                    stoppedOnError = true;
+                    break;
+                }
+            }
+            catch (error) {
+                const actionError = error instanceof Error ? error : new Error(String(error));
+                const errorResult = {
+                    success: false,
+                    error: actionError,
+                    executionTime: 0,
+                    action: actionName,
+                };
+                actionResults.push(errorResult);
+                stoppedOnError = true;
+                break;
+            }
+        }
+        // Perform rollback if enabled, errors occurred, and we have a snapshot
+        if (rollbackEnabled && stoppedOnError && snapshot && context.store) {
+            try {
+                this.restoreSnapshot(context, snapshot);
+                rolledBack = true;
+            }
+            catch (rollbackError) {
+                // eslint-disable-next-line no-console
+                console.error('[FieldTriggers] Rollback failed:', rollbackError);
+            }
+        }
+        const totalExecutionTime = performance.now() - startTime;
+        // Call global error handler if configured and errors occurred
+        const failedResults = actionResults.filter(r => !r.success);
+        if (failedResults.length > 0 && this.options.errorHandler) {
+            for (const failedResult of failedResults) {
+                try {
+                    this.options.errorHandler(failedResult.error, context, failedResult.action);
+                }
+                catch (handlerError) {
+                    // eslint-disable-next-line no-console
+                    console.error('[FieldTriggers] Error in global error handler:', handlerError);
+                }
+            }
+        }
+        const result = {
+            path: context.path,
+            actionResults,
+            totalExecutionTime,
+            allSucceeded: actionResults.every(r => r.success),
+            stoppedOnError,
+            rolledBack,
+            snapshot: this.options.debug && rollbackEnabled ? snapshot : undefined, // Only include snapshot in debug mode if rollback is enabled
+        };
+        return result;
+    }
+    /**
+     * 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)
+     */
+    async executeTransitionActions(context, options = {}) {
+        const { doctype, transition } = context;
+        const transitionActions = this.findTransitionActions(doctype, transition);
+        if (transitionActions.length === 0) {
+            return [];
+        }
+        const results = [];
+        // Execute transition actions sequentially
+        for (const actionName of transitionActions) {
+            try {
+                const actionResult = await this.executeTransitionAction(actionName, context, options.timeout);
+                results.push(actionResult);
+                if (!actionResult.success) {
+                    // Stop on first error for transitions
+                    break;
+                }
+            }
+            catch (error) {
+                const actionError = error instanceof Error ? error : new Error(String(error));
+                const errorResult = {
+                    success: false,
+                    error: actionError,
+                    executionTime: 0,
+                    action: actionName,
+                    transition,
+                };
+                results.push(errorResult);
+                break;
+            }
+        }
+        // Call global error handler if configured and errors occurred
+        const failedResults = results.filter(r => !r.success);
+        if (failedResults.length > 0 && this.options.errorHandler) {
+            for (const failedResult of failedResults) {
+                try {
+                    // Call with FieldChangeContext (base context type)
+                    this.options.errorHandler(failedResult.error, context, failedResult.action);
+                }
+                catch (handlerError) {
+                    // eslint-disable-next-line no-console
+                    console.error('[FieldTriggers] Error in global error handler:', handlerError);
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Find transition actions for a specific doctype and transition
+     */
+    findTransitionActions(doctype, transition) {
+        const doctypeTransitions = this.doctypeTransitions.get(doctype);
+        if (!doctypeTransitions)
+            return [];
+        return doctypeTransitions.get(transition) || [];
+    }
+    /**
+     * Execute a single transition action by name
+     */
+    async executeTransitionAction(actionName, context, timeout) {
+        const startTime = performance.now();
+        const actionTimeout = timeout ?? this.options.defaultTimeout;
+        try {
+            // Look up action in transition-specific registry first, then fall back to global
+            let actionFn = this.globalTransitionActions.get(actionName);
+            // If not found in transition registry, try regular action registry
+            // This allows sharing actions between field triggers and transitions
+            if (!actionFn) {
+                const regularActionFn = this.globalActions.get(actionName);
+                if (regularActionFn) {
+                    // Wrap regular action to accept TransitionChangeContext
+                    actionFn = regularActionFn;
+                }
+            }
+            if (!actionFn) {
+                throw new Error(`Transition action "${actionName}" not found in registry`);
+            }
+            await this.executeWithTimeout(actionFn, context, actionTimeout);
+            const executionTime = performance.now() - startTime;
+            return {
+                success: true,
+                executionTime,
+                action: actionName,
+                transition: context.transition,
+            };
+        }
+        catch (error) {
+            const executionTime = performance.now() - startTime;
+            const actionError = error instanceof Error ? error : new Error(String(error));
+            return {
+                success: false,
+                error: actionError,
+                executionTime,
+                action: actionName,
+                transition: context.transition,
+            };
+        }
+    }
+    /**
+     * 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)
+     */
+    findFieldTriggers(doctype, fieldname) {
+        const doctypeActions = this.doctypeActions.get(doctype);
+        if (!doctypeActions)
+            return [];
+        const triggers = [];
+        for (const [key, actionNames] of doctypeActions) {
+            // Check if this key is a field trigger pattern
+            if (this.isFieldTriggerKey(key, fieldname)) {
+                triggers.push(...actionNames);
+            }
+        }
+        return triggers;
+    }
+    /**
+     * 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"
+     */
+    isFieldTriggerKey(key, fieldname) {
+        // Exact match
+        if (key === fieldname)
+            return true;
+        // Contains dots - likely a field path pattern
+        if (key.includes('.')) {
+            return this.matchFieldPattern(key, fieldname);
+        }
+        // Contains wildcards
+        if (key.includes('*')) {
+            return this.matchFieldPattern(key, fieldname);
+        }
+        return false;
+    }
+    /**
+     * Match a field pattern against a field name
+     * Supports wildcards (*) for dynamic segments
+     */
+    matchFieldPattern(pattern, fieldname) {
+        const patternParts = pattern.split('.');
+        const fieldParts = fieldname.split('.');
+        if (patternParts.length !== fieldParts.length) {
+            return false;
+        }
+        for (let i = 0; i < patternParts.length; i++) {
+            const patternPart = patternParts[i];
+            const fieldPart = fieldParts[i];
+            if (patternPart === '*') {
+                // Wildcard matches any segment
+                continue;
+            }
+            else if (patternPart !== fieldPart) {
+                // Exact match required
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Execute a single action by name
+     */
+    async executeAction(actionName, context, timeout) {
+        const startTime = performance.now();
+        const actionTimeout = timeout ?? this.options.defaultTimeout;
+        try {
+            // Look up action in global registry
+            const actionFn = this.globalActions.get(actionName);
+            if (!actionFn) {
+                throw new Error(`Action "${actionName}" not found in registry`);
+            }
+            await this.executeWithTimeout(actionFn, context, actionTimeout);
+            const executionTime = performance.now() - startTime;
+            return {
+                success: true,
+                executionTime,
+                action: actionName,
+            };
+        }
+        catch (error) {
+            const executionTime = performance.now() - startTime;
+            const actionError = error instanceof Error ? error : new Error(String(error));
+            return {
+                success: false,
+                error: actionError,
+                executionTime,
+                action: actionName,
+            };
+        }
+    }
+    /**
+     * Execute a function with timeout
+     */
+    async executeWithTimeout(fn, context, timeout) {
+        return new Promise((resolve, reject) => {
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Action timeout after ${timeout}ms`));
+            }, timeout);
+            Promise.resolve(fn(context))
+                .then(result => {
+                clearTimeout(timeoutId);
+                resolve(result);
+            })
+                .catch(error => {
+                clearTimeout(timeoutId);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Capture a snapshot of the record state before executing actions
+     * This creates a deep copy of the record data for potential rollback
+     */
+    captureSnapshot(context) {
+        if (!context.store || !context.doctype || !context.recordId) {
+            return undefined;
+        }
+        try {
+            // Get the record path (doctype.recordId)
+            const recordPath = `${context.doctype}.${context.recordId}`;
+            // Get the current record data
+            const recordData = context.store.get(recordPath);
+            if (!recordData || typeof recordData !== 'object') {
+                return undefined;
+            }
+            // Create a deep copy to avoid reference issues
+            return JSON.parse(JSON.stringify(recordData));
+        }
+        catch (error) {
+            if (this.options.debug) {
+                // eslint-disable-next-line no-console
+                console.warn('[FieldTriggers] Failed to capture snapshot:', error);
+            }
+            return undefined;
+        }
+    }
+    /**
+     * Restore a previously captured snapshot
+     * This reverts the record to its state before actions were executed
+     */
+    restoreSnapshot(context, snapshot) {
+        if (!context.store || !context.doctype || !context.recordId || !snapshot) {
+            return;
+        }
+        try {
+            // Get the record path (doctype.recordId)
+            const recordPath = `${context.doctype}.${context.recordId}`;
+            // Restore the entire record from snapshot
+            context.store.set(recordPath, snapshot);
+            if (this.options.debug) {
+                // eslint-disable-next-line no-console
+                console.log(`[FieldTriggers] Rolled back ${recordPath} to previous state`);
+            }
+        }
+        catch (error) {
+            // eslint-disable-next-line no-console
+            console.error('[FieldTriggers] Failed to restore snapshot:', error);
+            throw error;
+        }
+    }
+}
+/**
+ * Get or create the global field trigger engine singleton
+ * @param options - Optional configuration for the field trigger engine
+ * @public
+ */
+export function getGlobalTriggerEngine(options) {
+    return new FieldTriggerEngine(options);
+}
+/**
+ * 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 function registerGlobalAction(name, fn) {
+    const engine = getGlobalTriggerEngine();
+    engine.registerAction(name, fn);
+}
+/**
+ * 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 function registerTransitionAction(name, fn) {
+    const engine = getGlobalTriggerEngine();
+    engine.registerTransitionAction(name, fn);
+}
+/**
+ * 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 function setFieldRollback(doctype, fieldname, enableRollback) {
+    const engine = getGlobalTriggerEngine();
+    engine.setFieldRollback(doctype, fieldname, enableRollback);
+}
+/**
+ * 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 async function triggerTransition(doctype, transition, options) {
+    const engine = getGlobalTriggerEngine();
+    const context = {
+        path: options?.path || (options?.recordId ? `${doctype}.${options.recordId}` : doctype),
+        fieldname: '',
+        beforeValue: undefined,
+        afterValue: undefined,
+        operation: 'set',
+        doctype,
+        recordId: options?.recordId,
+        timestamp: new Date(),
+        transition,
+        currentState: options?.currentState,
+        targetState: options?.targetState,
+        fsmContext: options?.fsmContext,
+    };
+    return await engine.executeTransitionActions(context);
+}
+/**
+ * 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 function markOperationIrreversible(operationId, reason) {
+    if (!operationId)
+        return;
+    try {
+        const store = useOperationLogStore();
+        store.markIrreversible(operationId, reason);
+    }
+    catch {
+        // Operation log is optional
+    }
+}

package/dist/src/index.d.ts

@@ -1,10 +1,18 @@
 export type * from '@stonecrop/aform/types';
 export type * from '@stonecrop/atable/types';
-import { type StonecropReturn, useStonecrop } from './composable';
+import { useStonecrop } from './composable';
+import { useOperationLog, useUndoRedoShortcuts, withBatch } from './composables/operation-log';
 import DoctypeMeta from './doctype';
+import { getGlobalTriggerEngine, markOperationIrreversible, registerGlobalAction, registerTransitionAction, setFieldRollback, triggerTransition } from './field-triggers';
+import plugin from './plugins';
 import Registry from './registry';
-import Stonecrop from './plugins';
-import { Stonecrop as StonecropClass } from './stonecrop';
+import { Stonecrop } from './stonecrop';
+import { HST, createHST, type HSTNode } from './stores/hst';
+import { useOperationLogStore } from './stores/operation-log';
 export type * from './types';
-export { DoctypeMeta, Registry, Stonecrop, StonecropClass, StonecropReturn, useStonecrop };
+export type { BaseStonecropReturn, HSTChangeData, HSTStonecropReturn, OperationLogAPI } from './composable';
+export type { FieldTriggerEngine } from './field-triggers';
+export type { FieldChangeContext, TransitionChangeContext, FieldTriggerExecutionResult, ActionExecutionResult, TransitionExecutionResult, FieldActionFunction, TransitionActionFunction, } from './types/field-triggers';
+export { DoctypeMeta, Registry, Stonecrop, useStonecrop, HST, createHST, HSTNode, getGlobalTriggerEngine, registerGlobalAction, registerTransitionAction, setFieldRollback, triggerTransition, markOperationIrreversible, useOperationLog, useOperationLogStore, useUndoRedoShortcuts, withBatch, };
+export default plugin;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,wBAAwB,CAAA;AAC3C,mBAAmB,yBAAyB,CAAA;AAE5C,OAAO,EAAE,KAAK,eAAe,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACjE,OAAO,WAAW,MAAM,WAAW,CAAA;AACnC,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,SAAS,MAAM,WAAW,CAAA;AACjC,OAAO,EAAE,SAAS,IAAI,cAAc,EAAE,MAAM,aAAa,CAAA;AACzD,mBAAmB,SAAS,CAAA;AAE5B,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,mBAAmB,wBAAwB,CAAA;AAC3C,mBAAmB,yBAAyB,CAAA;AAE5C,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAA;AAC9F,OAAO,WAAW,MAAM,WAAW,CAAA;AACnC,OAAO,EACN,sBAAsB,EACtB,yBAAyB,EACzB,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,kBAAkB,CAAA;AACzB,OAAO,MAAM,MAAM,WAAW,CAAA;AAC9B,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,mBAAmB,SAAS,CAAA;AAC5B,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC3G,YAAY,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAA;AAC1D,YAAY,EACX,kBAAkB,EAClB,uBAAuB,EACvB,2BAA2B,EAC3B,qBAAqB,EACrB,yBAAyB,EACzB,mBAAmB,EACnB,wBAAwB,GACxB,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EACN,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EAEZ,GAAG,EACH,SAAS,EACT,OAAO,EAEP,sBAAsB,EACtB,oBAAoB,EACpB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,yBAAyB,EAEzB,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,SAAS,GACT,CAAA;AAGD,eAAe,MAAM,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,18 @@
+import { useStonecrop } from './composable';
+import { useOperationLog, useUndoRedoShortcuts, withBatch } from './composables/operation-log';
+import DoctypeMeta from './doctype';
+import { getGlobalTriggerEngine, markOperationIrreversible, registerGlobalAction, registerTransitionAction, setFieldRollback, triggerTransition, } from './field-triggers';
+import plugin from './plugins';
+import Registry from './registry';
+import { Stonecrop } from './stonecrop';
+import { HST, createHST } from './stores/hst';
+import { useOperationLogStore } from './stores/operation-log';
+export { DoctypeMeta, Registry, Stonecrop, useStonecrop, 
+// HST exports for advanced usage
+HST, createHST, 
+// Field trigger system exports
+getGlobalTriggerEngine, registerGlobalAction, registerTransitionAction, setFieldRollback, triggerTransition, markOperationIrreversible, 
+// Operation log exports
+useOperationLog, useOperationLogStore, useUndoRedoShortcuts, withBatch, };
+// Default export is the Vue plugin
+export default plugin;

package/dist/src/plugins/index.d.ts

@@ -5,26 +5,24 @@ import { type Plugin } from 'vue';
  * @param options - The plugin options
  * @example
  * ```ts
- *
  * import { createApp } from 'vue'
- * import Stonecrop from 'stonecrop'
- *
- * import App from './App.vue'
+ * import Stonecrop from '@stonecrop/stonecrop'
+ * import router from './router'
  *
  * const app = createApp(App)
  * app.use(Stonecrop, {
- *  router,
- *  components: {
- *   // register custom components
- *  },
- *  getMeta: async (doctype: string) => {
- *   // fetch doctype meta from API
- *  },
+ *   router,
+ *   getMeta: async (routeContext) => {
+ *     // routeContext contains: { path, segments }
+ *     // fetch doctype meta from your API using the route context
+ *   },
+ *   autoInitializeRouter: true,
+ *   onRouterInitialized: async (registry, stonecrop) => {
+ *     // your custom initialization logic here
+ *   }
  * })
- *
  * app.mount('#app')
  * ```
- *
  * @public
  */
 declare const plugin: Plugin;

package/dist/src/plugins/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,MAAM,EAAE,MAAM,KAAK,CAAA;AAMtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,QAAA,MAAM,MAAM,EAAE,MAoBb,CAAA;AAED,eAAe,MAAM,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,MAAM,EAAY,MAAM,KAAK,CAAA;AA2BhD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,QAAA,MAAM,MAAM,EAAE,MAiDb,CAAA;AAED,eAAe,MAAM,CAAA"}