@stonecrop/schema 0.13.14 → 0.15.0

package/dist/jsonschema.js

@@ -1,225 +0,0 @@
-/**
- * Map StonecropFieldType to JSON Schema type
- */
-function fieldtypeToJSONSchema(fieldtype) {
-    const typeMap = {
-        Data: { type: 'string' },
-        Text: { type: 'string' },
-        Int: { type: 'integer' },
-        Float: { type: 'number' },
-        Decimal: { type: 'number' },
-        Check: { type: 'boolean' },
-        Date: { type: 'string', format: 'date' },
-        Time: { type: 'string', format: 'time' },
-        Datetime: { type: 'string', format: 'date-time' },
-        Duration: { type: 'string' },
-        DateRange: { type: 'object', properties: { start: { type: 'string', format: 'date' }, end: { type: 'string', format: 'date' } } },
-        JSON: { type: 'object', additionalProperties: true },
-        Code: { type: 'string' },
-        Link: { type: 'string', description: 'Reference to another doctype' },
-        Doctype: { type: 'array', items: { type: 'object' }, description: 'Child doctype records' },
-        Attach: { type: 'string', format: 'uri', description: 'File attachment URL' },
-        Currency: { type: 'number', description: 'Currency value' },
-        Quantity: { type: 'number', description: 'Quantity with unit' },
-        Select: { type: 'string' },
-    };
-    return typeMap[fieldtype] ?? { type: 'string' };
-}
-/**
- * Convert FieldOptions to JSON Schema additions
- */
-function fieldOptionsToJSONSchema(options, fieldtype) {
-    const schema = {};
-    if (fieldtype === 'Select' && Array.isArray(options)) {
-        schema.enum = options;
-    }
-    if (fieldtype === 'Link' && typeof options === 'string') {
-        schema.description = `Reference to ${options} doctype`;
-    }
-    if (fieldtype === 'Doctype' && typeof options === 'string') {
-        schema.description = `Child records from ${options} doctype`;
-        schema.items = { type: 'object', description: `${options} record` };
-    }
-    if (typeof options === 'object' && !Array.isArray(options)) {
-        if (fieldtype === 'Decimal' && 'precision' in options && 'scale' in options) {
-            const precision = options.precision;
-            const scale = options.scale;
-            schema.description = `Decimal(${precision}, ${scale})`;
-        }
-        if (fieldtype === 'Code' && 'language' in options) {
-            schema.description = `Code snippet (${options.language})`;
-        }
-    }
-    return schema;
-}
-/**
- * Convert a FieldMeta to JSON Schema
- */
-function fieldToJSONSchema(field) {
-    const baseSchema = fieldtypeToJSONSchema(field.fieldtype);
-    const optionsSchema = field.options ? fieldOptionsToJSONSchema(field.options, field.fieldtype) : {};
-    const schema = {
-        ...baseSchema,
-        ...optionsSchema,
-    };
-    if (field.label) {
-        schema.title = field.label;
-    }
-    if (field.default !== undefined) {
-        schema.default = field.default;
-    }
-    if (field.hidden) {
-        schema['x-hidden'] = true;
-    }
-    if (field.readOnly) {
-        schema.readOnly = true;
-    }
-    if (field.width) {
-        schema['x-width'] = field.width;
-    }
-    if (field.align) {
-        schema['x-align'] = field.align;
-    }
-    return schema;
-}
-/**
- * Convert a DoctypeMeta to JSON Schema
- *
- * @param doctype - The doctype definition to convert
- * @returns JSON Schema representation of the doctype
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toJSONSchema } from '@stonecrop/schema'
- *
- * const taskDoctype = DoctypeMeta.parse({
- *   name: 'Task',
- *   fields: [
- *     { fieldname: 'title', fieldtype: 'Data', required: true },
- *     { fieldname: 'status', fieldtype: 'Select', options: ['Open', 'Closed'] }
- *   ]
- * })
- *
- * const jsonSchema = toJSONSchema(taskDoctype)
- * // => {
- * //   schema: { type: 'object', properties: { title: {...}, status: {...} }, required: ['title'] },
- * //   meta: { name: 'Task' }
- * // }
- * ```
- *
- * @public
- */
-export function toJSONSchema(doctype) {
-    const properties = {};
-    const required = [];
-    for (const field of doctype.fields) {
-        properties[field.fieldname] = fieldToJSONSchema(field);
-        if (field.required) {
-            required.push(field.fieldname);
-        }
-    }
-    const schema = {
-        $schema: 'https://json-schema.org/draft/2020-12/schema',
-        type: 'object',
-        properties,
-        title: doctype.name,
-    };
-    if (required.length > 0) {
-        schema.required = required;
-    }
-    if (doctype.slug) {
-        schema['x-slug'] = doctype.slug;
-    }
-    if (doctype.tableName) {
-        schema['x-tableName'] = doctype.tableName;
-    }
-    const result = {
-        schema,
-        meta: {
-            name: doctype.name,
-            slug: doctype.slug,
-            tableName: doctype.tableName,
-            inherits: doctype.inherits,
-            listDoctype: doctype.listDoctype,
-            parentDoctype: doctype.parentDoctype,
-        },
-    };
-    if (doctype.workflow) {
-        result.workflow = {
-            states: doctype.workflow.states,
-            actions: doctype.workflow.actions ? workflowActionsToJSON(doctype.workflow.actions) : undefined,
-        };
-    }
-    return result;
-}
-/**
- * Convert workflow actions to JSON Schema friendly format
- */
-function workflowActionsToJSON(actions) {
-    const result = {};
-    for (const [name, action] of Object.entries(actions)) {
-        result[name] = {
-            label: action.label,
-            handler: action.handler,
-            requiredFields: action.requiredFields,
-            allowedStates: action.allowedStates,
-            confirm: action.confirm,
-            args: action.args,
-        };
-    }
-    return result;
-}
-/**
- * Generate a collection of JSON Schemas from multiple doctypes
- *
- * @param doctypes - Array of doctype definitions
- * @returns Map of doctype name to JSON Schema
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toSchemasCollection } from '@stonecrop/schema'
- *
- * const doctypes = [
- *   DoctypeMeta.parse({ name: 'Task', fields: [...] }),
- *   DoctypeMeta.parse({ name: 'Customer', fields: [...] }),
- * ]
- *
- * const collection = toSchemasCollection(doctypes)
- * // => { Task: {...}, Customer: {...} }
- * ```
- *
- * @public
- */
-export function toSchemasCollection(doctypes) {
-    const collection = {};
-    for (const doctype of doctypes) {
-        collection[doctype.name] = toJSONSchema(doctype);
-    }
-    return collection;
-}
-/**
- * Generate OpenAPI schema components from doctypes
- *
- * @param doctypes - Array of doctype definitions
- * @returns OpenAPI 3.1 compatible components object
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toOpenAPIComponents } from '@stonecrop/schema'
- *
- * const doctypes = [DoctypeMeta.parse({ name: 'Task', fields: [...] })]
- *
- * const components = toOpenAPIComponents(doctypes)
- * // => { schemas: { Task: {...} } }
- * ```
- *
- * @public
- */
-export function toOpenAPIComponents(doctypes) {
-    const schemas = {};
-    for (const doctype of doctypes) {
-        const { schema } = toJSONSchema(doctype);
-        schemas[doctype.name] = schema;
-    }
-    return { schemas };
-}

package/dist/naming.js

@@ -1,106 +0,0 @@
-/**
- * Naming Convention Utilities
- * Converts between various naming conventions (snake_case, camelCase, PascalCase, kebab-case)
- * @packageDocumentation
- */
-/**
- * Converts snake_case to camelCase
- * @param snakeCase - Snake case string
- * @returns Camel case string
- * @public
- * @example
- * ```typescript
- * snakeToCamel('user_email') // 'userEmail'
- * snakeToCamel('created_at') // 'createdAt'
- * ```
- */
-export function snakeToCamel(snakeCase) {
-    return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-}
-/**
- * Converts camelCase to snake_case
- * @param camelCase - Camel case string
- * @returns Snake case string
- * @public
- * @example
- * ```typescript
- * camelToSnake('userEmail') // 'user_email'
- * camelToSnake('createdAt') // 'created_at'
- * ```
- */
-export function camelToSnake(camelCase) {
-    return camelCase.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
-}
-/**
- * Converts snake_case to Title Case label
- * @param snakeCase - Snake case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * snakeToLabel('user_email') // 'User Email'
- * snakeToLabel('first_name') // 'First Name'
- * ```
- */
-export function snakeToLabel(snakeCase) {
-    return snakeCase
-        .split('_')
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join(' ');
-}
-/**
- * Converts camelCase to Title Case label
- * @param camelCase - Camel case string
- * @returns Title case label
- * @public
- * @example
- * ```typescript
- * camelToLabel('userEmail') // 'User Email'
- * camelToLabel('firstName') // 'First Name'
- * ```
- */
-export function camelToLabel(camelCase) {
-    const withSpaces = camelCase.replace(/([A-Z])/g, ' $1').trim();
-    return withSpaces.charAt(0).toUpperCase() + withSpaces.slice(1);
-}
-/**
- * Convert table name to PascalCase doctype name
- * @param tableName - SQL table name (snake_case)
- * @returns PascalCase name
- * @public
- */
-export function toPascalCase(tableName) {
-    return tableName
-        .split(/[-_\s]+/)
-        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-        .join('');
-}
-/**
- * Convert to kebab-case slug
- * @param name - Name to convert
- * @returns kebab-case slug
- * @public
- */
-export function toSlug(name) {
-    return name
-        .replace(/([a-z])([A-Z])/g, '$1-$2')
-        .replace(/[\s_]+/g, '-')
-        .toLowerCase();
-}
-/**
- * Convert PascalCase to snake_case (e.g., for deriving table names from type names)
- * @param pascal - PascalCase string
- * @returns snake_case string
- * @public
- * @example
- * ```typescript
- * pascalToSnake('SalesOrder') // 'sales_order'
- * pascalToSnake('SalesOrderItem') // 'sales_order_item'
- * ```
- */
-export function pascalToSnake(pascal) {
-    return pascal
-        .replace(/([a-z])([A-Z])/g, '$1_$2')
-        .replace(/[\s-]+/g, '_')
-        .toLowerCase();
-}

package/dist/src/fieldtype.d.ts

@@ -1,63 +0,0 @@
-import { z } from 'zod';
-/**
- * The complete list of field types built into Stonecrop.
- * User apps can use any string as a fieldtype; this const is the exhaustive set of types
- * that Stonecrop provides default components for.
- * @public
- */
-export declare const BUILTIN_FIELD_TYPES: readonly ["Data", "Text", "Int", "Float", "Decimal", "Check", "Date", "Time", "Datetime", "Duration", "DateRange", "JSON", "Code", "Link", "Attach", "Currency", "Quantity", "Select", "PrimaryKey", "Fieldset", "Display"];
-/**
- * Union of all builtin fieldtype string literals.
- * @public
- */
-export type BuiltinFieldType = (typeof BUILTIN_FIELD_TYPES)[number];
-/**
- * Stonecrop field type — any non-empty string is valid; Stonecrop provides default components
- * for the builtin types listed in {@link BUILTIN_FIELD_TYPES}. Custom fieldtypes are supported
- * by supplying an explicit `component` on the field definition.
- * @public
- */
-export declare const StonecropFieldType: z.ZodString;
-/**
- * Returns `true` when `fieldtype` is one of the builtin types Stonecrop ships with.
- * @public
- */
-export declare function isBuiltinFieldType(fieldtype: string): fieldtype is BuiltinFieldType;
-/**
- * Field template for TYPE_MAP entries.
- * Defines the default component and semantic field type for a field.
- * @public
- */
-export interface FieldTemplate {
-    /**
-     * The Vue component name to render this field (e.g., 'ATextInput', 'ADropdown')
-     */
-    component: string;
-    /**
-     * The semantic field type (e.g., 'Data', 'Int', 'Select')
-     */
-    fieldtype: BuiltinFieldType;
-}
-/**
- * Mapping from builtin fieldtypes to their default Vue component.
- * Components can be overridden in the field definition.
- * @public
- */
-export declare const TYPE_MAP: Record<BuiltinFieldType, FieldTemplate>;
-/**
- * Get the default component for a builtin field type.
- * For an open-string fieldtype that may be custom, use {@link resolveComponent} instead.
- * @param fieldtype - A builtin field type
- * @returns The default component name
- * @public
- */
-export declare function getDefaultComponent(fieldtype: BuiltinFieldType): string;
-/**
- * Resolve the component name for any fieldtype string, falling back to `'ATextInput'`
- * for unknown custom types.
- * @param fieldtype - Any fieldtype string (builtin or custom)
- * @returns The component name to use for rendering
- * @public
- */
-export declare function resolveComponent(fieldtype: string): string;
-//# sourceMappingURL=fieldtype.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fieldtype.d.ts","sourceRoot":"","sources":["../../src/fieldtype.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,6NAsBtB,CAAA;AAEV;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,aAG7B,CAAA;AAEF;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,IAAI,gBAAgB,CAEnF;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,SAAS,EAAE,MAAM,CAAA;IACjB;;OAEG;IACH,SAAS,EAAE,gBAAgB,CAAA;CAC3B;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,gBAAgB,EAAE,aAAa,CAyC5D,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,gBAAgB,GAAG,MAAM,CAEvE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/dist/src/fieldtype.js

@@ -1,105 +0,0 @@
-import { z } from 'zod';
-/**
- * The complete list of field types built into Stonecrop.
- * User apps can use any string as a fieldtype; this const is the exhaustive set of types
- * that Stonecrop provides default components for.
- * @public
- */
-export const BUILTIN_FIELD_TYPES = [
-    'Data', // Short text, varchar
-    'Text', // Long text
-    'Int', // Integer
-    'Float', // Floating point (IEEE 754)
-    'Decimal', // Arbitrary precision decimal
-    'Check', // Boolean/checkbox
-    'Date', // Date only
-    'Time', // Time only
-    'Datetime', // Date and time
-    'Duration', // Time interval
-    'DateRange', // Date range
-    'JSON', // JSON data
-    'Code', // Code/source (with syntax highlighting)
-    'Link', // Reference to another doctype
-    'Attach', // File attachment
-    'Currency', // Currency value
-    'Quantity', // Quantity with unit
-    'Select', // Dropdown selection
-    'PrimaryKey', // Primary key field — used by the middleware to identify the record's PK column
-    'Fieldset', // UI grouping container — no DB column; children are flat columns
-    'Display', // Computed/read-only field — no DB column; excluded from SQL SELECT
-];
-/**
- * Stonecrop field type — any non-empty string is valid; Stonecrop provides default components
- * for the builtin types listed in {@link BUILTIN_FIELD_TYPES}. Custom fieldtypes are supported
- * by supplying an explicit `component` on the field definition.
- * @public
- */
-export const StonecropFieldType = z.string().min(1).meta({
-    title: 'StonecropFieldType',
-    description: 'Semantic field types for Stonecrop doctypes, consistent across forms and tables',
-});
-/**
- * Returns `true` when `fieldtype` is one of the builtin types Stonecrop ships with.
- * @public
- */
-export function isBuiltinFieldType(fieldtype) {
-    return BUILTIN_FIELD_TYPES.includes(fieldtype);
-}
-/**
- * Mapping from builtin fieldtypes to their default Vue component.
- * Components can be overridden in the field definition.
- * @public
- */
-export const TYPE_MAP = {
-    // Text
-    Data: { component: 'ATextInput', fieldtype: 'Data' },
-    Text: { component: 'ATextInput', fieldtype: 'Text' },
-    // Numeric
-    Int: { component: 'ANumericInput', fieldtype: 'Int' },
-    Float: { component: 'ANumericInput', fieldtype: 'Float' },
-    Decimal: { component: 'ADecimalInput', fieldtype: 'Decimal' },
-    // Boolean
-    Check: { component: 'ACheckbox', fieldtype: 'Check' },
-    // Date/Time
-    Date: { component: 'ADate', fieldtype: 'Date' },
-    Time: { component: 'ATimeInput', fieldtype: 'Time' },
-    Datetime: { component: 'ADatetimePicker', fieldtype: 'Datetime' },
-    Duration: { component: 'ADurationInput', fieldtype: 'Duration' },
-    DateRange: { component: 'ADateRangePicker', fieldtype: 'DateRange' },
-    // Structured
-    JSON: { component: 'ACodeEditor', fieldtype: 'JSON' },
-    Code: { component: 'ACodeEditor', fieldtype: 'Code' },
-    // Relational
-    Link: { component: 'ALink', fieldtype: 'Link' },
-    // Files
-    Attach: { component: 'AFileAttach', fieldtype: 'Attach' },
-    // Specialized
-    Currency: { component: 'ACurrencyInput', fieldtype: 'Currency' },
-    Quantity: { component: 'AQuantityInput', fieldtype: 'Quantity' },
-    Select: { component: 'ADropdown', fieldtype: 'Select' },
-    // Identity — PK fields are typically hidden; no interactive component is needed
-    PrimaryKey: { component: 'ATextInput', fieldtype: 'PrimaryKey' },
-    // Layout — UI grouping containers and computed fields with no backing DB column
-    Fieldset: { component: 'AFieldset', fieldtype: 'Fieldset' },
-    Display: { component: 'ATextInput', fieldtype: 'Display' },
-};
-/**
- * Get the default component for a builtin field type.
- * For an open-string fieldtype that may be custom, use {@link resolveComponent} instead.
- * @param fieldtype - A builtin field type
- * @returns The default component name
- * @public
- */
-export function getDefaultComponent(fieldtype) {
-    return TYPE_MAP[fieldtype]?.component ?? 'ATextInput';
-}
-/**
- * Resolve the component name for any fieldtype string, falling back to `'ATextInput'`
- * for unknown custom types.
- * @param fieldtype - Any fieldtype string (builtin or custom)
- * @returns The component name to use for rendering
- * @public
- */
-export function resolveComponent(fieldtype) {
-    return isBuiltinFieldType(fieldtype) ? getDefaultComponent(fieldtype) : 'ATextInput';
-}

package/dist/src/jsonschema.d.ts

@@ -1,95 +0,0 @@
-import type { DoctypeMeta } from './doctype';
-/**
- * JSON Schema representation for a doctype
- * @public
- */
-export interface DoctypeJSONSchema {
-    /** JSON Schema for the doctype structure */
-    schema: Record<string, unknown>;
-    /** Metadata from the doctype definition */
-    meta: {
-        name: string;
-        slug?: string;
-        tableName?: string;
-        inherits?: string;
-        listDoctype?: string;
-        parentDoctype?: string;
-    };
-    /** Workflow metadata if present */
-    workflow?: {
-        states?: string[];
-        actions?: Record<string, Record<string, unknown>>;
-    };
-}
-/**
- * Convert a DoctypeMeta to JSON Schema
- *
- * @param doctype - The doctype definition to convert
- * @returns JSON Schema representation of the doctype
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toJSONSchema } from '@stonecrop/schema'
- *
- * const taskDoctype = DoctypeMeta.parse({
- *   name: 'Task',
- *   fields: [
- *     { fieldname: 'title', fieldtype: 'Data', required: true },
- *     { fieldname: 'status', fieldtype: 'Select', options: ['Open', 'Closed'] }
- *   ]
- * })
- *
- * const jsonSchema = toJSONSchema(taskDoctype)
- * // => {
- * //   schema: { type: 'object', properties: { title: {...}, status: {...} }, required: ['title'] },
- * //   meta: { name: 'Task' }
- * // }
- * ```
- *
- * @public
- */
-export declare function toJSONSchema(doctype: DoctypeMeta): DoctypeJSONSchema;
-/**
- * Generate a collection of JSON Schemas from multiple doctypes
- *
- * @param doctypes - Array of doctype definitions
- * @returns Map of doctype name to JSON Schema
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toSchemasCollection } from '@stonecrop/schema'
- *
- * const doctypes = [
- *   DoctypeMeta.parse({ name: 'Task', fields: [...] }),
- *   DoctypeMeta.parse({ name: 'Customer', fields: [...] }),
- * ]
- *
- * const collection = toSchemasCollection(doctypes)
- * // => { Task: {...}, Customer: {...} }
- * ```
- *
- * @public
- */
-export declare function toSchemasCollection(doctypes: DoctypeMeta[]): Record<string, DoctypeJSONSchema>;
-/**
- * Generate OpenAPI schema components from doctypes
- *
- * @param doctypes - Array of doctype definitions
- * @returns OpenAPI 3.1 compatible components object
- *
- * @example
- * ```typescript
- * import { DoctypeMeta, toOpenAPIComponents } from '@stonecrop/schema'
- *
- * const doctypes = [DoctypeMeta.parse({ name: 'Task', fields: [...] })]
- *
- * const components = toOpenAPIComponents(doctypes)
- * // => { schemas: { Task: {...} } }
- * ```
- *
- * @public
- */
-export declare function toOpenAPIComponents(doctypes: DoctypeMeta[]): {
-    schemas: Record<string, Record<string, unknown>>;
-};
-//# sourceMappingURL=jsonschema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"jsonschema.d.ts","sourceRoot":"","sources":["../../src/jsonschema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAkC,MAAM,WAAW,CAAA;AAI5E;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IACjC,4CAA4C;IAC5C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAE/B,2CAA2C;IAC3C,IAAI,EAAE;QACL,IAAI,EAAE,MAAM,CAAA;QACZ,IAAI,CAAC,EAAE,MAAM,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,QAAQ,CAAC,EAAE,MAAM,CAAA;QACjB,WAAW,CAAC,EAAE,MAAM,CAAA;QACpB,aAAa,CAAC,EAAE,MAAM,CAAA;KACtB,CAAA;IAED,mCAAmC;IACnC,QAAQ,CAAC,EAAE;QACV,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;KACjD,CAAA;CACD;AAuGD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,GAAG,iBAAiB,CAmDpE;AAsBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAQ9F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG;IAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CAAE,CASjH"}

package/dist/src/schema-field.d.ts

@@ -1,66 +0,0 @@
-/**
- * Minimal field shape representing the intersection of form field properties
- * (fieldname, hidden, etc.) and table column properties (cellComponent, pinned, format, etc.)
- * so that a doctype's fields array can be passed directly to table components without
- * requiring callers to pre-build TableColumn objects.
- *
- * Notes on specific properties:
- * - `align` uses an explicit string union rather than CanvasTextAlign — this
- *   package is used server-side by the CLI where browser DOM types are absent.
- * - `format` is a serialized function string; the table store's getFormattedValue
- *   already handles typeof format === 'string' via Function(...).
- * - `mask` is intentionally omitted — ACell has mask commented out as a TODO
- *   and TableColumn.mask is function-typed only; including it here would create
- *   an incompatible type.
- * - `modalComponent` is string-only (no function variant) — functions cannot
- *   appear in schema JSON.
- *
- * @public
- */
-export interface ColumnSchema {
-    /** Unique identifier for the field within its doctype. Maps to `name` on `TableColumn`. */
-    fieldname: string;
-    /** Semantic field type (e.g. `'Data'`, `'Int'`, `'Date'`, `'Check'`). Fields without a `fieldtype` are treated as non-scalar (nested table/fieldset) and excluded by `schemaToColumns`. */
-    fieldtype?: string;
-    /** Human-readable column header. */
-    label?: string;
-    /** When `true`, the field is excluded from the derived columns by `schemaToColumns`. */
-    hidden?: boolean;
-    /** Horizontal text alignment for the column cell and header. */
-    align?: 'left' | 'right' | 'center' | 'start' | 'end';
-    /** Whether the column cell is editable in the table. */
-    edit?: boolean;
-    /** CSS width of the column (e.g. `'20ch'`, `'200px'`). */
-    width?: string;
-    /** When `true`, the column is pinned to the left side of the table. */
-    pinned?: boolean;
-    /** When `true`, the column can be resized by dragging the header edge. */
-    resizable?: boolean;
-    /** When `true`, clicking the column header sorts the table by this column. */
-    sortable?: boolean;
-    /** When `true`, a filter control is rendered in the column header. */
-    filterable?: boolean;
-    /** The type of filter control to render. Defaults are derived from `fieldtype` when absent. */
-    filterType?: 'text' | 'select' | 'number' | 'date' | 'dateRange' | 'checkbox' | 'component';
-    /** Static option list for `filterType: 'select'`. When absent, options are derived from unique row values. */
-    filterOptions?: any[];
-    /** Registered component name used when `filterType` is `'component'`. */
-    filterComponent?: string;
-    /** Registered component name rendered inside the table cell instead of the default display. */
-    cellComponent?: string;
-    /** Props passed to `cellComponent`. */
-    cellComponentProps?: Record<string, any>;
-    /** Registered component name rendered in the cell's modal editor. String-only — functions cannot appear in schema JSON. */
-    modalComponent?: string;
-    /** Extra props passed to `modalComponent` in addition to the standard cell props. */
-    modalComponentExtraProps?: Record<string, any>;
-    /** Serialized function string used to format the cell value for display. Deserialized at render time by the table store's `getFormattedValue`. */
-    format?: string;
-    /** When `true`, this column is treated as a Gantt bar column. */
-    isGantt?: boolean;
-    /** Registered component name used to render Gantt bars in this column. */
-    ganttComponent?: string;
-    /** Number of columns this cell spans in the table layout. */
-    colspan?: number;
-}
-//# sourceMappingURL=schema-field.d.ts.map

package/dist/src/schema-field.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-field.d.ts","sourceRoot":"","sources":["../../src/schema-field.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,YAAY;IAC5B,2FAA2F;IAC3F,SAAS,EAAE,MAAM,CAAA;IACjB,2LAA2L;IAC3L,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,oCAAoC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,wFAAwF;IACxF,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,KAAK,CAAA;IACrD,wDAAwD;IACxD,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uEAAuE;IACvE,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,sEAAsE;IACtE,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,+FAA+F;IAC/F,UAAU,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAA;IAC3F,8GAA8G;IAC9G,aAAa,CAAC,EAAE,GAAG,EAAE,CAAA;IACrB,yEAAyE;IACzE,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,+FAA+F;IAC/F,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,uCAAuC;IACvC,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACxC,2HAA2H;IAC3H,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,qFAAqF;IACrF,wBAAwB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC9C,kJAAkJ;IAClJ,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iEAAiE;IACjE,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,0EAA0E;IAC1E,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,CAAA;CAChB"}