@stonecrop/stonecrop 0.6.2 → 0.6.3

package/dist/composable.js

@@ -0,0 +1,348 @@
+// src/composable.ts
+import { inject, onMounted, ref, watch, provide, computed } from 'vue';
+import { Stonecrop } from './stonecrop';
+import { storeToRefs } from 'pinia';
+/**
+ * @public
+ */
+export function useStonecrop(options) {
+    if (!options)
+        options = {};
+    const registry = options.registry || inject('$registry');
+    const providedStonecrop = inject('$stonecrop');
+    const stonecrop = ref();
+    const hstStore = ref();
+    const formData = ref({});
+    // Use refs for router-loaded doctype to maintain reactivity
+    const routerDoctype = ref();
+    const routerRecordId = ref();
+    // Operation log state and methods - will be populated after stonecrop instance is created
+    const operations = ref([]);
+    const currentIndex = ref(-1);
+    const canUndo = computed(() => stonecrop.value?.getOperationLogStore().canUndo ?? false);
+    const canRedo = computed(() => stonecrop.value?.getOperationLogStore().canRedo ?? false);
+    const undoCount = computed(() => stonecrop.value?.getOperationLogStore().undoCount ?? 0);
+    const redoCount = computed(() => stonecrop.value?.getOperationLogStore().redoCount ?? 0);
+    const undoRedoState = computed(() => stonecrop.value?.getOperationLogStore().undoRedoState ?? {
+        canUndo: false,
+        canRedo: false,
+        undoCount: 0,
+        redoCount: 0,
+        currentIndex: -1,
+    });
+    // Operation log methods
+    const undo = (hstStore) => {
+        return stonecrop.value?.getOperationLogStore().undo(hstStore) ?? false;
+    };
+    const redo = (hstStore) => {
+        return stonecrop.value?.getOperationLogStore().redo(hstStore) ?? false;
+    };
+    const startBatch = () => {
+        stonecrop.value?.getOperationLogStore().startBatch();
+    };
+    const commitBatch = (description) => {
+        return stonecrop.value?.getOperationLogStore().commitBatch(description) ?? null;
+    };
+    const cancelBatch = () => {
+        stonecrop.value?.getOperationLogStore().cancelBatch();
+    };
+    const clear = () => {
+        stonecrop.value?.getOperationLogStore().clear();
+    };
+    const getOperationsFor = (doctype, recordId) => {
+        return stonecrop.value?.getOperationLogStore().getOperationsFor(doctype, recordId) ?? [];
+    };
+    const getSnapshot = () => {
+        return (stonecrop.value?.getOperationLogStore().getSnapshot() ?? {
+            operations: [],
+            currentIndex: -1,
+            totalOperations: 0,
+            reversibleOperations: 0,
+            irreversibleOperations: 0,
+        });
+    };
+    const markIrreversible = (operationId, reason) => {
+        stonecrop.value?.getOperationLogStore().markIrreversible(operationId, reason);
+    };
+    const logAction = (doctype, actionName, recordIds, result = 'success', error) => {
+        return stonecrop.value?.getOperationLogStore().logAction(doctype, actionName, recordIds, result, error) ?? '';
+    };
+    const configure = (config) => {
+        stonecrop.value?.getOperationLogStore().configure(config);
+    };
+    // Initialize Stonecrop instance
+    onMounted(async () => {
+        if (!registry) {
+            return;
+        }
+        stonecrop.value = providedStonecrop || new Stonecrop(registry);
+        // Set up reactive refs from operation log store - only if Pinia is available
+        try {
+            const opLogStore = stonecrop.value.getOperationLogStore();
+            const opLogRefs = storeToRefs(opLogStore);
+            operations.value = opLogRefs.operations.value;
+            currentIndex.value = opLogRefs.currentIndex.value;
+            // Watch for changes in operation log state
+            watch(() => opLogRefs.operations.value, newOps => {
+                operations.value = newOps;
+            });
+            watch(() => opLogRefs.currentIndex.value, newIndex => {
+                currentIndex.value = newIndex;
+            });
+        }
+        catch {
+            // Pinia not available (e.g., in tests) - operation log features will not be available
+            // Silently fail - operation log is optional
+        }
+        // Handle router-based setup if no specific doctype provided
+        if (!options.doctype && registry.router) {
+            const route = registry.router.currentRoute.value;
+            // Parse route path - let the application determine the doctype from the route
+            if (!route.path)
+                return; // Early return if no path available
+            const pathSegments = route.path.split('/').filter(segment => segment.length > 0);
+            const recordId = pathSegments[1]?.toLowerCase();
+            if (pathSegments.length > 0) {
+                // Create route context for getMeta function
+                const routeContext = {
+                    path: route.path,
+                    segments: pathSegments,
+                };
+                const doctype = await registry.getMeta?.(routeContext);
+                if (doctype) {
+                    registry.addDoctype(doctype);
+                    stonecrop.value.setup(doctype);
+                    // Set reactive refs for router-based doctype
+                    routerDoctype.value = doctype;
+                    routerRecordId.value = recordId;
+                    hstStore.value = stonecrop.value.getStore();
+                    if (recordId && recordId !== 'new') {
+                        const existingRecord = stonecrop.value.getRecordById(doctype, recordId);
+                        if (existingRecord) {
+                            formData.value = existingRecord.get('') || {};
+                        }
+                        else {
+                            try {
+                                await stonecrop.value.getRecord(doctype, recordId);
+                                const loadedRecord = stonecrop.value.getRecordById(doctype, recordId);
+                                if (loadedRecord) {
+                                    formData.value = loadedRecord.get('') || {};
+                                }
+                            }
+                            catch {
+                                formData.value = initializeNewRecord(doctype);
+                            }
+                        }
+                    }
+                    else {
+                        formData.value = initializeNewRecord(doctype);
+                    }
+                    if (hstStore.value) {
+                        setupDeepReactivity(doctype, recordId || 'new', formData, hstStore.value);
+                    }
+                    stonecrop.value.runAction(doctype, 'load', recordId ? [recordId] : undefined);
+                }
+            }
+        }
+        // Handle HST integration if doctype is provided explicitly
+        if (options.doctype) {
+            hstStore.value = stonecrop.value.getStore();
+            const doctype = options.doctype;
+            const recordId = options.recordId;
+            if (recordId && recordId !== 'new') {
+                const existingRecord = stonecrop.value.getRecordById(doctype, recordId);
+                if (existingRecord) {
+                    formData.value = existingRecord.get('') || {};
+                }
+                else {
+                    try {
+                        await stonecrop.value.getRecord(doctype, recordId);
+                        const loadedRecord = stonecrop.value.getRecordById(doctype, recordId);
+                        if (loadedRecord) {
+                            formData.value = loadedRecord.get('') || {};
+                        }
+                    }
+                    catch {
+                        formData.value = initializeNewRecord(doctype);
+                    }
+                }
+            }
+            else {
+                formData.value = initializeNewRecord(doctype);
+            }
+            if (hstStore.value) {
+                setupDeepReactivity(doctype, recordId || 'new', formData, hstStore.value);
+            }
+        }
+    });
+    // HST integration functions - always created but only populated when HST is available
+    const provideHSTPath = (fieldname, customRecordId) => {
+        const doctype = options.doctype || routerDoctype.value;
+        if (!doctype)
+            return '';
+        const actualRecordId = customRecordId || options.recordId || routerRecordId.value || 'new';
+        return `${doctype.slug}.${actualRecordId}.${fieldname}`;
+    };
+    const handleHSTChange = (changeData) => {
+        const doctype = options.doctype || routerDoctype.value;
+        if (!hstStore.value || !stonecrop.value || !doctype) {
+            return;
+        }
+        try {
+            const pathParts = changeData.path.split('.');
+            if (pathParts.length >= 2) {
+                const doctypeSlug = pathParts[0];
+                const recordId = pathParts[1];
+                if (!hstStore.value.has(`${doctypeSlug}.${recordId}`)) {
+                    stonecrop.value.addRecord(doctype, recordId, { ...formData.value });
+                }
+                if (pathParts.length > 3) {
+                    const recordPath = `${doctypeSlug}.${recordId}`;
+                    const nestedParts = pathParts.slice(2);
+                    let currentPath = recordPath;
+                    for (let i = 0; i < nestedParts.length - 1; i++) {
+                        currentPath += `.${nestedParts[i]}`;
+                        if (!hstStore.value.has(currentPath)) {
+                            const nextPart = nestedParts[i + 1];
+                            const isArray = !isNaN(Number(nextPart));
+                            hstStore.value.set(currentPath, isArray ? [] : {});
+                        }
+                    }
+                }
+            }
+            hstStore.value.set(changeData.path, changeData.value);
+            const fieldParts = changeData.fieldname.split('.');
+            const newFormData = { ...formData.value };
+            if (fieldParts.length === 1) {
+                newFormData[fieldParts[0]] = changeData.value;
+            }
+            else {
+                updateNestedObject(newFormData, fieldParts, changeData.value);
+            }
+            formData.value = newFormData;
+        }
+        catch {
+            // Silently handle errors
+        }
+    };
+    // Provide injection tokens if HST will be available
+    if (options.doctype || registry?.router) {
+        provide('hstPathProvider', provideHSTPath);
+        provide('hstChangeHandler', handleHSTChange);
+    }
+    // Create operation log API object
+    const operationLog = {
+        operations,
+        currentIndex,
+        undoRedoState,
+        canUndo,
+        canRedo,
+        undoCount,
+        redoCount,
+        undo,
+        redo,
+        startBatch,
+        commitBatch,
+        cancelBatch,
+        clear,
+        getOperationsFor,
+        getSnapshot,
+        markIrreversible,
+        logAction,
+        configure,
+    };
+    // Always return HST functions if doctype is provided or will be loaded from router
+    if (options.doctype) {
+        // Explicit doctype - return HST immediately
+        return {
+            stonecrop,
+            operationLog,
+            provideHSTPath,
+            handleHSTChange,
+            hstStore,
+            formData,
+        };
+    }
+    else if (!options.doctype && registry?.router) {
+        // Router-based - return HST (will be populated after mount)
+        return {
+            stonecrop,
+            operationLog,
+            provideHSTPath,
+            handleHSTChange,
+            hstStore,
+            formData,
+        };
+    }
+    // No doctype and no router - basic mode
+    return {
+        stonecrop,
+        operationLog,
+    };
+}
+/**
+ * Initialize new record structure based on doctype schema
+ */
+function initializeNewRecord(doctype) {
+    const initialData = {};
+    if (!doctype.schema) {
+        return initialData;
+    }
+    doctype.schema.forEach(field => {
+        const fieldtype = 'fieldtype' in field ? field.fieldtype : 'Data';
+        switch (fieldtype) {
+            case 'Data':
+            case 'Text':
+                initialData[field.fieldname] = '';
+                break;
+            case 'Check':
+                initialData[field.fieldname] = false;
+                break;
+            case 'Int':
+            case 'Float':
+                initialData[field.fieldname] = 0;
+                break;
+            case 'Table':
+                initialData[field.fieldname] = [];
+                break;
+            case 'JSON':
+                initialData[field.fieldname] = {};
+                break;
+            default:
+                initialData[field.fieldname] = null;
+        }
+    });
+    return initialData;
+}
+/**
+ * Setup deep reactivity between form data and HST store
+ */
+function setupDeepReactivity(doctype, recordId, formData, hstStore) {
+    watch(formData, newData => {
+        const recordPath = `${doctype.slug}.${recordId}`;
+        Object.keys(newData).forEach(fieldname => {
+            const path = `${recordPath}.${fieldname}`;
+            try {
+                hstStore.set(path, newData[fieldname]);
+            }
+            catch {
+                // Silently handle errors
+            }
+        });
+    }, { deep: true });
+}
+/**
+ * Update nested object with dot-notation path
+ */
+function updateNestedObject(obj, path, value) {
+    let current = obj;
+    for (let i = 0; i < path.length - 1; i++) {
+        const key = path[i];
+        if (!(key in current) || typeof current[key] !== 'object') {
+            current[key] = isNaN(Number(path[i + 1])) ? {} : [];
+        }
+        current = current[key];
+    }
+    const finalKey = path[path.length - 1];
+    current[finalKey] = value;
+}

package/dist/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/doctype.js

@@ -0,0 +1,73 @@
+/**
+ * Doctype Meta class
+ * @public
+ */
+export default class DoctypeMeta {
+    /**
+     * The doctype name
+     * @public
+     * @readonly
+     */
+    doctype;
+    /**
+     * The doctype schema
+     * @public
+     * @readonly
+     */
+    schema;
+    /**
+     * The doctype workflow
+     * @public
+     * @readonly
+     */
+    workflow;
+    /**
+     * The doctype actions and field triggers
+     * @public
+     * @readonly
+     */
+    actions;
+    /**
+     * The doctype component
+     * @public
+     * @readonly
+     */
+    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, schema, workflow, actions, component) {
+        this.doctype = doctype;
+        this.schema = schema;
+        this.workflow = workflow;
+        this.actions = actions;
+        this.component = component;
+    }
+    /**
+     * Converts the registered doctype string to a slug (kebab-case). The following conversions are made:
+     * - It replaces camelCase and PascalCase with kebab-case strings
+     * - It replaces spaces and underscores with hyphens
+     * - It converts the string to lowercase
+     *
+     * @returns The slugified doctype string
+     *
+     * @example
+     * ```ts
+     * const doctype = new DoctypeMeta('TaskItem', schema, workflow, actions
+     * console.log(doctype.slug) // 'task-item'
+     * ```
+     *
+     * @public
+     */
+    get slug() {
+        return this.doctype
+            .replace(/([a-z])([A-Z])/g, '$1-$2')
+            .replace(/[\s_]+/g, '-')
+            .toLowerCase();
+    }
+}

package/dist/exceptions.js

@@ -0,0 +1,16 @@
+/**
+ * NotImplementedError
+ * @param message {string} - The error message
+ * @class
+ * @description This error is thrown when a method has not been implemented
+ * @example
+ * throw new NotImplementedError('Method not implemented')
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error|Error}
+ * @public
+ */
+export class NotImplementedError extends Error {
+    constructor(message = '') {
+        super(message);
+        this.name = 'NotImplemented';
+    }
+}