@stonecrop/stonecrop 0.11.0 → 0.11.2

package/dist/src/composables/use-stonecrop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-stonecrop.d.ts","sourceRoot":"","sources":["../../../src/composables/use-stonecrop.ts"],"names":[],"mappings":"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"}

package/dist/src/composables/useNestedSchema.d.ts

@@ -1,110 +0,0 @@
-import { type Ref } from 'vue';
-import type { SchemaTypes } from '@stonecrop/aform/types';
-/**
- * Registry interface for schema lookup
- * Compatible with Stonecrop Registry but doesn't require it as a dependency
- * @public
- */
-export interface SchemaRegistry {
-    /**
-     * Map of doctype slugs to their metadata including schema, slug, and doctype name
-     */
-    registry: Record<string, {
-        doctype: string;
-        slug: string;
-        schema?: SchemaTypes[] | Iterable<SchemaTypes>;
-    }>;
-}
-/**
- * Options for useNestedSchema composable
- * @public
- */
-export interface UseNestedSchemaOptions {
-    /**
-     * The target doctype slug to load schema for
-     */
-    doctype: string;
-    /**
-     * Registry instance for schema lookup (optional)
-     * If not provided, you must supply schema directly via setSchema
-     */
-    registry?: SchemaRegistry;
-    /**
-     * Direct schema array to use instead of loading from registry
-     */
-    schema?: SchemaTypes[];
-    /**
-     * Initial data for the nested form
-     */
-    initialData?: any;
-}
-/**
- * Return type for useNestedSchema composable
- * @public
- */
-export interface UseNestedSchemaReturn {
-    /**
-     * The loaded/provided nested schema
-     */
-    schema: Ref<SchemaTypes[] | undefined>;
-    /**
-     * Error message if schema loading fails
-     */
-    error: Ref<string | undefined>;
-    /**
-     * Loading state
-     */
-    loading: Ref<boolean>;
-    /**
-     * Initialize empty record data based on schema
-     */
-    initializeRecord: () => Record<string, any>;
-    /**
-     * Initialize array of records
-     */
-    initializeArray: (count: number) => Record<string, any>[];
-    /**
-     * Manually set schema (useful if not using registry)
-     */
-    setSchema: (newSchema: SchemaTypes[]) => void;
-    /**
-     * Load schema from registry
-     */
-    loadSchema: () => Promise<void>;
-    /**
-     * Get the doctype name (display name)
-     */
-    doctypeName: Ref<string>;
-}
-/**
- * Composable for managing nested schema loading and initialization
- *
- * This composable provides utilities for working with nested doctypes in forms
- * without being tightly coupled to Stonecrop or any specific state management solution.
- *
- * **Note:** This composable supports 1:1 nested schemas only. For 1:many relationships,
- * use nested table schemas which provide proper doctype mapping.
- *
- * @example
- * ```typescript
- * // With Stonecrop registry
- * const { schema, initializeRecord, loadSchema } = useNestedSchema({
- *   doctype: 'address',
- *   registry: stonecrop.registry,
- * })
- * await loadSchema()
- *
- * // With direct schema
- * const { schema, initializeRecord } = useNestedSchema({
- *   doctype: 'address',
- *   schema: addressSchema,
- * })
- *
- * // Initialize data
- * const emptyAddress = initializeRecord()
- * ```
- *
- * @internal
- */
-export declare function useNestedSchema(options: UseNestedSchemaOptions): UseNestedSchemaReturn;
-//# sourceMappingURL=useNestedSchema.d.ts.map

package/dist/src/composables/useNestedSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useNestedSchema.d.ts","sourceRoot":"","sources":["../../../src/composables/useNestedSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAEnC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AAEzD;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,QAAQ,EAAE,MAAM,CACf,MAAM,EACN;QACC,OAAO,EAAE,MAAM,CAAA;QACf,IAAI,EAAE,MAAM,CAAA;QACZ,MAAM,CAAC,EAAE,WAAW,EAAE,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAA;KAC9C,CACD,CAAA;CACD;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAA;IAEf;;;OAGG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAA;IAEzB;;OAEG;IACH,MAAM,CAAC,EAAE,WAAW,EAAE,CAAA;IAEtB;;OAEG;IACH,WAAW,CAAC,EAAE,GAAG,CAAA;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACrC;;OAEG;IACH,MAAM,EAAE,GAAG,CAAC,WAAW,EAAE,GAAG,SAAS,CAAC,CAAA;IAEtC;;OAEG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;IAE9B;;OAEG;IACH,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAErB;;OAEG;IACH,gBAAgB,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAE3C;;OAEG;IACH,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,CAAA;IAEzD;;OAEG;IACH,SAAS,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,IAAI,CAAA;IAE7C;;OAEG;IACH,UAAU,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAE/B;;OAEG;IACH,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,qBAAqB,CAwItF"}

package/dist/src/composables/useNestedSchema.js

@@ -1,155 +0,0 @@
-import { ref } from 'vue';
-/**
- * Composable for managing nested schema loading and initialization
- *
- * This composable provides utilities for working with nested doctypes in forms
- * without being tightly coupled to Stonecrop or any specific state management solution.
- *
- * **Note:** This composable supports 1:1 nested schemas only. For 1:many relationships,
- * use nested table schemas which provide proper doctype mapping.
- *
- * @example
- * ```typescript
- * // With Stonecrop registry
- * const { schema, initializeRecord, loadSchema } = useNestedSchema({
- *   doctype: 'address',
- *   registry: stonecrop.registry,
- * })
- * await loadSchema()
- *
- * // With direct schema
- * const { schema, initializeRecord } = useNestedSchema({
- *   doctype: 'address',
- *   schema: addressSchema,
- * })
- *
- * // Initialize data
- * const emptyAddress = initializeRecord()
- * ```
- *
- * @internal
- */
-export function useNestedSchema(options) {
-    const schema = ref();
-    const error = ref();
-    const loading = ref(false);
-    const doctypeName = ref(options.doctype);
-    // Initialize with provided schema if available
-    if (options.schema) {
-        schema.value = options.schema;
-    }
-    // Initialize with provided data if available
-    if (options.initialData) {
-        // Data is provided externally, composable just manages schema
-    }
-    /**
-     * Load schema from registry
-     */
-    const loadSchema = async () => {
-        if (!options.registry) {
-            error.value = 'No registry provided and no schema set directly';
-            return;
-        }
-        loading.value = true;
-        error.value = undefined;
-        try {
-            // Get doctype from registry
-            const doctype = options.registry.registry[options.doctype];
-            if (!doctype) {
-                error.value = `Doctype '${options.doctype}' not found in registry`;
-                return;
-            }
-            doctypeName.value = doctype.doctype;
-            // Convert schema to array (handles both arrays and Immutable Lists)
-            if (Array.isArray(doctype.schema)) {
-                schema.value = doctype.schema;
-            }
-            else if (doctype.schema && typeof doctype.schema[Symbol.iterator] === 'function') {
-                schema.value = Array.from(doctype.schema);
-            }
-            else {
-                error.value = 'Invalid schema format';
-            }
-        }
-        catch (err) {
-            error.value = `Failed to load schema: ${err instanceof Error ? err.message : String(err)}`;
-        }
-        finally {
-            loading.value = false;
-        }
-    };
-    /**
-     * Manually set schema
-     */
-    const setSchema = (newSchema) => {
-        schema.value = newSchema;
-        error.value = undefined;
-    };
-    /**
-     * Initialize empty record based on schema
-     */
-    const initializeRecord = () => {
-        const initialData = {};
-        if (!schema.value) {
-            return initialData;
-        }
-        schema.value.forEach(field => {
-            const fieldtype = 'fieldtype' in field ? field.fieldtype : 'Data';
-            const fieldname = field.fieldname;
-            // Provide sensible defaults based on field type
-            switch (fieldtype) {
-                case 'Data':
-                case 'Text':
-                    initialData[fieldname] = '';
-                    break;
-                case 'Check':
-                    initialData[fieldname] = false;
-                    break;
-                case 'Int':
-                case 'Float':
-                case 'Decimal':
-                    initialData[fieldname] = 0;
-                    break;
-                case 'Doctype':
-                    // Initialize nested Doctype fields as empty objects (1:1 only)
-                    initialData[fieldname] = {};
-                    break;
-                case 'JSON':
-                    initialData[fieldname] = {};
-                    break;
-                case 'Date':
-                case 'Time':
-                case 'Datetime':
-                    initialData[fieldname] = null;
-                    break;
-                default:
-                    initialData[fieldname] = null;
-            }
-            // Use default value if specified in schema
-            if ('default' in field && field.default !== undefined) {
-                initialData[fieldname] = field.default;
-            }
-        });
-        return initialData;
-    };
-    /**
-     * Initialize array of records
-     */
-    const initializeArray = (count) => {
-        return Array.from({ length: count }, () => initializeRecord());
-    };
-    // Auto-load if registry is provided
-    if (options.registry && !options.schema) {
-        void loadSchema();
-    }
-    return {
-        schema,
-        error,
-        loading,
-        doctypeName,
-        initializeRecord,
-        initializeArray,
-        setSchema,
-        loadSchema,
-    };
-}

package/dist/src/doctype.js

@@ -1,234 +0,0 @@
-import { List, Map } from 'immutable';
-/**
- * Doctype runtime class with Immutable.js collections for HST change tracking.
- * @public
- */
-export default class Doctype {
-    /**
-     * The doctype name
-     * @public
-     * @readonly
-     */
-    doctype;
-    /**
-     * Alias for doctype (for DoctypeLike interface compatibility)
-     * @public
-     * @readonly
-     */
-    get name() {
-        return this.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 Doctype 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;
-    }
-    /**
-     * Creates a Doctype instance from a plain configuration object.
-     * Handles conversion of arrays to Immutable.js collections internally.
-     *
-     * This is the recommended way to create a Doctype from API responses
-     * or configuration files, as it encapsulates the Immutable.js construction
-     * that the framework uses internally.
-     *
-     * @param config - Plain object with doctype configuration (typically from API response)
-     * @returns A new Doctype instance with Immutable.js collections
-     *
-     * @example
-     * ```ts
-     * // From an API response
-     * const response = await client.getMeta({ doctype: 'plan' })
-     * const doctype = Doctype.fromObject(response)
-     * registry.addDoctype(doctype)
-     * ```
-     *
-     * @example
-     * ```ts
-     * // From a configuration object
-     * const planDoctype = Doctype.fromObject({
-     *   name: 'Plan',
-     *   fields: [
-     *     { fieldname: 'title', label: 'Title', fieldtype: 'Data' },
-     *     { fieldname: 'status', label: 'Status', fieldtype: 'Data' },
-     *   ],
-     *   workflow: {
-     *     id: 'plan',
-     *     initial: 'draft',
-     *     states: { draft: {}, submitted: {} }
-     *   }
-     * })
-     * ```
-     *
-     * @public
-     */
-    static fromObject(config) {
-        const schema = config.fields ? List(config.fields) : List();
-        const actions = config.actions ? Map(config.actions) : Map();
-        return new Doctype(config.name, schema, config.workflow, actions);
-    }
-    /**
-     * Returns the schema as a plain array for use with components that expect
-     * plain JavaScript arrays (e.g., AForm, ATable).
-     *
-     * @returns Array of schema fields
-     *
-     * @example
-     * ```ts
-     * const schemaArray = doctype.getSchemaArray()
-     * // Use with AForm
-     * <AForm :schema="schemaArray" v-model:data="formData" />
-     * ```
-     *
-     * @public
-     */
-    getSchemaArray() {
-        if (!this.schema)
-            return [];
-        return this.schema.toArray();
-    }
-    /**
-     * Returns the actions as a plain object for use with components that expect
-     * plain JavaScript objects.
-     *
-     * @returns Object mapping action names to field trigger arrays
-     *
-     * @public
-     */
-    getActionsObject() {
-        if (!this.actions)
-            return {};
-        return this.actions.toObject();
-    }
-    /**
-     * Returns the transitions available from a given workflow state, derived from the
-     * doctype's workflow configuration. Supports both XState format and WorkflowMeta format.
-     *
-     * @param currentState - The state name to read transitions from
-     * @returns Array of transition descriptors with `name` and `targetState`
-     *
-     * @example
-     * ```ts
-     * const transitions = doctype.getAvailableTransitions('draft')
-     * // [{ name: 'SUBMIT', targetState: 'submitted' }]
-     * ```
-     *
-     * @public
-     */
-    getAvailableTransitions(currentState) {
-        const workflow = this.workflow;
-        if (!workflow)
-            return [];
-        // Check if this is WorkflowMeta format (states is an array) or XState format (states is an object)
-        if (Array.isArray(workflow.states)) {
-            // WorkflowMeta format: validate state exists and filter actions by allowedStates
-            const states = workflow.states;
-            if (!states.includes(currentState))
-                return [];
-            const actions = workflow.actions;
-            if (!actions)
-                return [];
-            return Object.entries(actions)
-                .filter(([, actionDef]) => {
-                const allowedStates = actionDef.allowedStates;
-                // If no allowedStates specified, action is available in all valid states
-                if (!allowedStates || allowedStates.length === 0)
-                    return true;
-                return allowedStates.includes(currentState);
-            })
-                .map(([name]) => ({
-                name,
-                // WorkflowMeta doesn't define target states - transitions are handled server-side
-                targetState: currentState,
-            }));
-        }
-        // XState format: use the on property of the state
-        const states = workflow.states;
-        if (!states)
-            return [];
-        const stateConfig = states[currentState];
-        if (!stateConfig?.on)
-            return [];
-        return Object.entries(stateConfig.on).map(([name, target]) => ({
-            name,
-            targetState: typeof target === 'string' ? target : 'unknown',
-        }));
-    }
-    /**
-     * Returns metadata for a specific action, if available.
-     * Only works with WorkflowMeta format; returns undefined for XState format.
-     *
-     * @param actionName - The action name to get metadata for
-     * @returns Action metadata or undefined
-     *
-     * @example
-     * ```ts
-     * const actionMeta = doctype.getActionMeta('submit')
-     * // { label: 'Submit', handler: 'plan:submit', allowedStates: ['draft'] }
-     * ```
-     *
-     * @public
-     */
-    getActionMeta(actionName) {
-        const workflow = this.workflow;
-        if (!workflow || !Array.isArray(workflow.states))
-            return undefined;
-        const actions = workflow.actions;
-        return actions?.[actionName];
-    }
-    /**
-     * 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 Doctype('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/src/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';
-    }
-}