@stonecrop/stonecrop 0.6.3 → 0.7.0

package/dist/composable.js

@@ -1,348 +0,0 @@
-// 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

@@ -1,221 +0,0 @@
-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

@@ -1,73 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-/**
- * 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';
-    }
-}