@stonecrop/stonecrop 0.4.36 → 0.5.0

package/README.md

@@ -1,6 +1,75 @@
 # Stonecrop
 _This package is under active development / design._
 
+## Features
+
+- **Hierarchical State Tree (HST)**: Advanced state management with tree navigation
+- **Operation Log**: Global undo/redo with time-travel debugging, automatic FSM transition tracking, and action execution tracking
+- **Action Tracking**: Audit trail for stateless action executions (print, email, archive, etc.)
+- **Field Triggers**: Event-driven field actions integrated with XState
+- **VueUse Integration**: Leverages battle-tested VueUse composables for keyboard shortcuts and persistence
+
+## Installation & Usage
+
+### Vue Plugin Installation
+
+```typescript
+import { createApp } from 'vue'
+import Stonecrop from '@stonecrop/stonecrop'
+
+const app = createApp(App)
+
+// Install the Stonecrop plugin
+app.use(Stonecrop, {
+  router,
+  components: {
+    // Register custom components
+  },
+  getMeta: async (doctype: string) => {
+    // Fetch doctype metadata from your API
+    return await fetchDoctypeMeta(doctype)
+  }
+})
+
+app.mount('#app')
+```
+
+### Available Imports
+
+```typescript
+// Default export - Vue plugin
+import Stonecrop from '@stonecrop/stonecrop'
+
+// Named exports - utilities and classes
+import {
+  Stonecrop as StonecropClass, // Core class
+  Registry,                    // Doctype registry
+  useStonecrop,                // Vue composable
+  HST,                         // Hierarchical State Tree
+  createHST,                   // HST factory
+  DoctypeMeta                  // Doctype metadata class
+} from '@stonecrop/stonecrop'
+```### Using the Composable
+
+```typescript
+import { useStonecrop } from '@stonecrop/stonecrop'
+
+export default {
+  setup() {
+    const { stonecrop } = useStonecrop()
+
+    // Access HST store
+    const store = stonecrop.value?.getStore()
+
+    // Work with records
+    const records = stonecrop.value?.records('doctype')
+    const record = stonecrop.value?.getRecordById('doctype', recordId)
+
+    return { stonecrop, records, record }
+  }
+}
+```
+
 ## Design
 A context will define schema, workflow and actions.
   - Schema describes the data model and layout of the document.
@@ -27,11 +96,9 @@ app.doctype.schema.field.workflow <FSM>
 app.doctype.schema.field.actions <OrderedSet>
 app.doctype.schema.field.value <Store>
 app.doctype.schema.field.value.field.value <Store> // a "sub-form"
-app.doctype.schema.field.value.field[0].value <Store> // also a "sub-form", likely representing a table or list
+app.doctype.schema.field.value.field['a:1'].value <Store> // also a "sub-form", representing a table
 ```
 
-It may make sense to use [automatic injection aliasing](https://vuejs.org/guide/components/provide-inject.html#inject) at the doctype level
-
 ## Base Classes
 The Doctype aligns with a row, record or object in a database. It is required to specify its schema, a Finite State Machine that informs its workflow and a set of functions that are triggered by that FSM's state transitions.
 
@@ -60,3 +127,25 @@ Stem is a composable singleton that wraps Registry and provides application leve
 - User can define `doctype` and schema from UI
 - Fields are shown as rows in a table
 - FSM is shown as an editable diagram that validates itself
+
+___
+
+# Hierarchical State Tree (HST) Interface Requirements
+
+## Core Requirements
+
+### 1. Data Structure Compatibility
+- **Vue Reactive Objects**: Must work seamlessly with `reactive()`, `ref()`, and `computed()` primitives
+- **Pinia Store Integration**: Compatible with both Options API and Composition API Pinia stores
+- **Immutable Objects**: Support for frozen/immutable configuration objects without breaking reactivity
+
+### 2. Path-Based Addressing System
+- **Dot Notation**: Full support for dot-notation paths (e.g., `"users.123.profile.settings"`)
+- **Dynamic Paths**: Support for programmatically generated path strings (particularly component to HST)
+
+### 3. Hierarchical Navigation
+- **Parent/Child Relationships**: Maintain bidirectional parent-child references
+- **Sibling Access**: Efficient navigation between sibling nodes
+- **Root Access**: Always accessible reference to tree root from any node
+- **Depth Tracking**: Know the depth level of any node in the hierarchy
+- **Breadcrumb Generation**: Generate full path breadcrumbs for any node

package/dist/src/composable.d.ts

@@ -1,19 +1,85 @@
-import { Ref } from 'vue';
+import { Ref, ComputedRef } from 'vue';
 import Registry from './registry';
 import { Stonecrop } from './stonecrop';
+import DoctypeMeta from './doctype';
+import type { HSTNode } from './stores/hst';
+import type { HSTOperation, OperationLogConfig, OperationLogSnapshot } from './types/operation-log';
 /**
- * Stonecrop composable return type
+ * Operation Log API - nested object containing all operation log functionality
  * @public
  */
-export type StonecropReturn = {
+export type OperationLogAPI = {
+    operations: Ref<HSTOperation[]>;
+    currentIndex: Ref<number>;
+    undoRedoState: ComputedRef<{
+        canUndo: boolean;
+        canRedo: boolean;
+        undoCount: number;
+        redoCount: number;
+        currentIndex: number;
+    }>;
+    canUndo: ComputedRef<boolean>;
+    canRedo: ComputedRef<boolean>;
+    undoCount: ComputedRef<number>;
+    redoCount: 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) => HSTOperation[];
+    getSnapshot: () => 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;
+};
+/**
+ * Base Stonecrop composable return type - includes operation log functionality
+ * @public
+ */
+export type BaseStonecropReturn = {
     stonecrop: Ref<Stonecrop | undefined>;
+    operationLog: OperationLogAPI;
+};
+/**
+ * HST-enabled Stonecrop composable return type
+ * @public
+ */
+export type HSTStonecropReturn = BaseStonecropReturn & {
+    provideHSTPath: (fieldname: string, recordId?: string) => string;
+    handleHSTChange: (changeData: HSTChangeData) => void;
+    hstStore: Ref<HSTNode | undefined>;
+    formData: Ref<Record<string, any>>;
 };
 /**
- * Stonecrop composable
- * @param registry - An existing Stonecrop Registry instance
- * @returns The Stonecrop instance and a boolean indicating if Stonecrop is setup and ready
- * @throws Error if the Stonecrop plugin is not enabled before using the composable
+ * HST Change data structure
+ * @public
+ */
+export type HSTChangeData = {
+    path: string;
+    value: any;
+    fieldname: string;
+    recordId?: string;
+};
+/**
+ * Unified Stonecrop composable - handles both general operations and HST reactive integration
+ *
+ * @param options - Configuration options for the composable
+ * @returns Stonecrop instance and optional HST integration utilities
+ * @public
+ */
+export declare function useStonecrop(): BaseStonecropReturn | HSTStonecropReturn;
+/**
+ * Unified Stonecrop composable with HST integration for a specific doctype and record
+ *
+ * @param options - Configuration with doctype and optional recordId
+ * @returns Stonecrop instance with full HST integration utilities
  * @public
  */
-export declare function useStonecrop(registry?: Registry): StonecropReturn;
+export declare function useStonecrop(options: {
+    registry?: Registry;
+    doctype: DoctypeMeta;
+    recordId?: string;
+}): HSTStonecropReturn;
 //# sourceMappingURL=composable.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"composable.d.ts","sourceRoot":"","sources":["../../src/composable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,GAAG,EAAO,MAAM,KAAK,CAAA;AAEjD,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAGvC;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC7B,SAAS,EAAE,GAAG,CAAC,SAAS,GAAG,SAAS,CAAC,CAAA;CACrC,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,QAAQ,CAAC,EAAE,QAAQ,GAAG,eAAe,CA8CjE"}
+{"version":3,"file":"composable.d.ts","sourceRoot":"","sources":["../../src/composable.ts"],"names":[],"mappings":"AACA,OAAO,EAAqB,GAAG,EAAiC,WAAW,EAAE,MAAM,KAAK,CAAA;AAExF,OAAO,QAAQ,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACvC,OAAO,WAAW,MAAM,WAAW,CAAA;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAG3C,OAAO,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAA;AAEnG;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC7B,UAAU,EAAE,GAAG,CAAC,YAAY,EAAE,CAAC,CAAA;IAC/B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB,aAAa,EAAE,WAAW,CAAC;QAC1B,OAAO,EAAE,OAAO,CAAA;QAChB,OAAO,EAAE,OAAO,CAAA;QAChB,SAAS,EAAE,MAAM,CAAA;QACjB,SAAS,EAAE,MAAM,CAAA;QACjB,YAAY,EAAE,MAAM,CAAA;KACpB,CAAC,CAAA;IACF,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,OAAO,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IAC7B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC9B,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;IAC9B,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAA;IACpC,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,KAAK,OAAO,CAAA;IACpC,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,WAAW,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAA;IACpD,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,YAAY,EAAE,CAAA;IACxE,WAAW,EAAE,MAAM,oBAAoB,CAAA;IACvC,gBAAgB,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAC/D,SAAS,EAAE,CACV,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,SAAS,CAAC,EAAE,MAAM,EAAE,EACpB,MAAM,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,EAC1C,KAAK,CAAC,EAAE,MAAM,KACV,MAAM,CAAA;IACX,SAAS,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,kBAAkB,CAAC,KAAK,IAAI,CAAA;CACzD,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IACjC,SAAS,EAAE,GAAG,CAAC,SAAS,GAAG,SAAS,CAAC,CAAA;IACrC,YAAY,EAAE,eAAe,CAAA;CAC7B,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,mBAAmB,GAAG;IACtD,cAAc,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAA;IAChE,eAAe,EAAE,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,CAAA;IACpD,QAAQ,EAAE,GAAG,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;IAClC,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAA;CAClC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,GAAG,CAAA;IACV,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,mBAAmB,GAAG,kBAAkB,CAAA;AACxE;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE;IACrC,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,OAAO,EAAE,WAAW,CAAA;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAA;CACjB,GAAG,kBAAkB,CAAA"}

package/dist/src/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;
+}