@donotdev/crud 0.0.3 → 0.0.5

package/dist/forms/utils/createEntitySchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createEntitySchema.d.ts","sourceRoot":"","sources":["../../../src/forms/utils/createEntitySchema.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAe,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAyIvE;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,MAAM,EACjD,MAAM,EAAE,CAAC,EACT,SAAS,GAAE,eAA0B,GACpC,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAkDtC"}

package/dist/forms/utils/createEntitySchema.js

@@ -0,0 +1 @@
+import*as e from"valibot";import{TECHNICAL_FIELD_NAMES as m}from"@donotdev/schemas";function f(n,t={}){const{type:l,validation:a}=n,{isDraft:s=!1}=t;let i;switch(l){case"number":case"range":i=e.number(),a?.min!==void 0&&(i=e.pipe(i,e.minValue(a.min))),a?.max!==void 0&&(i=e.pipe(i,e.maxValue(a.max)));break;case"boolean":case"checkbox":i=e.boolean();break;case"email":i=e.pipe(e.string(),e.email());break;case"url":i=e.pipe(e.string(),e.url());break;case"multiselect":case"array":i=e.array(e.string());break;case"select":case"radio":if(a?.options&&Array.isArray(a.options)){const c=a.options.map(o=>o.value);i=e.picklist(c)}else i=e.string();break;case"date":case"datetime-local":case"time":case"month":case"week":case"timestamp":i=e.string();break;case"image":i=e.object({fullUrl:e.string(),thumbUrl:e.optional(e.string())});break;case"images":i=e.array(e.object({fullUrl:e.string(),thumbUrl:e.optional(e.string())}));break;default:i=e.string(),a?.minLength!==void 0&&(i=e.pipe(i,e.minLength(a.minLength))),a?.maxLength!==void 0&&(i=e.pipe(i,e.maxLength(a.maxLength))),a?.pattern&&(i=e.pipe(i,e.regex(new RegExp(a.pattern))));break}return(!a?.required||s)&&(i=e.optional(i)),i}function d(n,t="create"){const l=t==="draft",a={};for(const[i,c]of Object.entries(n.fields)){if(c.visibility==="hidden")continue;const o=m.includes(i);let r=f(c,{isDraft:l});(t==="create"||t==="draft")&&o&&(r=e.optional(r)),t==="update"&&i!=="id"&&(r=e.optional(r)),a[i]=r}t==="update"&&(a.id=e.pipe(e.string(),e.minLength(1,"ID is required")));const s=e.object(a);return s.metadata={collection:n.collection,entity:n.name},s}export{d as createEntitySchema};

package/dist/forms/utils/getFieldsForOperation.d.ts

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Field filtering utility
+ * @description Filters entity fields based on operation type, visibility, and viewer role.
+ *
+ * @version 0.0.1
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+import type { Entity, EntityField, FieldConfig, FieldType } from '@donotdev/core';
+/** Entity fields input - supports Entity, Entity['fields'], or plain Record */
+export type EntityFieldsInput = Entity | Entity['fields'] | Record<string, EntityField<FieldType> | FieldConfig<FieldType>>;
+import { type ViewerRole } from './isFieldEditable';
+/** Field with computed editability for rendering */
+export interface RenderableField<T extends FieldType = FieldType> {
+    /** Field name/key */
+    name: string;
+    /** Normalized field configuration */
+    config: FieldConfig<T>;
+    /** Whether field is editable (input vs read-only) */
+    editable: boolean;
+}
+/** Options for field filtering */
+export interface GetFieldsForOperationOptions {
+    /** Form operation type */
+    operation: 'create' | 'edit';
+    /** Viewer role for editability checks */
+    viewerRole?: ViewerRole;
+    /**
+     * Available field names (for edit mode).
+     * When provided, only fields in this list are returned.
+     * Typically comes from Object.keys(defaultValues) - backend-filtered data.
+     */
+    availableFields?: string[];
+}
+/**
+ * Filters entity fields based on operation type and viewer role.
+ *
+ * Pure function, no React dependencies. Use for building custom form layouts.
+ *
+ * **Create operation:**
+ * - Excludes `visibility: 'technical'` fields (auto-added by backend)
+ * - Excludes `visibility: 'hidden'` fields (never shown)
+ *
+ * **Edit operation:**
+ * - Excludes `visibility: 'hidden'` fields (never shown)
+ * - Technical fields are marked as `editable: false` (read-only)
+ * - If `availableFields` provided, only returns fields in that list (backend-filtered)
+ *
+ * @param entity - Entity definition from defineEntity()
+ * @param options - Filtering options
+ * @returns Array of renderable fields with computed editability
+ *
+ * @example
+ * ```typescript
+ * import { getFieldsForOperation } from '@donotdev/crud/forms';
+ * import { productEntity } from './entities/product';
+ *
+ * // Create form - excludes technical and hidden
+ * const createFields = getFieldsForOperation(productEntity, {
+ *   operation: 'create',
+ *   viewerRole: 'user'
+ * });
+ *
+ * // Edit form - uses backend-filtered fields
+ * const editFields = getFieldsForOperation(productEntity, {
+ *   operation: 'edit',
+ *   viewerRole: 'admin',
+ *   availableFields: Object.keys(existingData)
+ * });
+ *
+ * // Render custom form
+ * editFields.map(({ name, config, editable }) => (
+ *   editable
+ *     ? <Input key={name} {...config} />
+ *     : <ReadOnlyDisplay key={name} {...config} />
+ * ));
+ * ```
+ *
+ * @see {@link Entity} for entity definition structure
+ * @see {@link RenderableField} for return type
+ *
+ * @version 0.0.1
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+export declare function getFieldsForOperation(entity: EntityFieldsInput, options: GetFieldsForOperationOptions): RenderableField[];
+//# sourceMappingURL=getFieldsForOperation.d.ts.map

package/dist/forms/utils/getFieldsForOperation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFieldsForOperation.d.ts","sourceRoot":"","sources":["../../../src/forms/utils/getFieldsForOperation.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACV,MAAM,EACN,WAAW,EACX,WAAW,EACX,SAAS,EACV,MAAM,gBAAgB,CAAC;AAExB,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GACzB,MAAM,GACN,MAAM,CAAC,QAAQ,CAAC,GAChB,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,SAAS,CAAC,GAAG,WAAW,CAAC,SAAS,CAAC,CAAC,CAAC;AAGpE,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAErE,oDAAoD;AACpD,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS;IAC9D,qBAAqB;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,qCAAqC;IACrC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACvB,qDAAqD;IACrD,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,kCAAkC;AAClC,MAAM,WAAW,4BAA4B;IAC3C,0BAA0B;IAC1B,SAAS,EAAE,QAAQ,GAAG,MAAM,CAAC;IAC7B,yCAAyC;IACzC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,iBAAiB,EACzB,OAAO,EAAE,4BAA4B,GACpC,eAAe,EAAE,CAyDnB"}

package/dist/forms/utils/getFieldsForOperation.js

@@ -0,0 +1 @@
+import{normalizeToFieldConfig as f}from"./normalizeToFieldConfig";import{isFieldEditable as u}from"./isFieldEditable";function F(e,s){const{operation:r,viewerRole:d="admin",availableFields:t}=s,a=e&&typeof e=="object"&&"fields"in e&&"name"in e?e.fields:e;return Object.entries(a).map(([i,c])=>{const n=f(i,c),l=n.visibility||"user";if(r==="create"){if(l==="technical"||l==="hidden")return null}else if(l==="hidden"||t&&!t.includes(i))return null;let o=u(n.editable,d,r);return r==="edit"&&l==="technical"&&n.editable===void 0&&(o=!1),{name:i,config:n,editable:o}}).filter(i=>i!==null)}export{F as getFieldsForOperation};

package/dist/forms/utils/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @fileoverview Form utilities barrel export
+ * @description Exports all form utility functions for custom form building.
+ *
+ * @version 0.0.1
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+export { isFieldEditable, type ViewerRole } from './isFieldEditable';
+export { normalizeToFieldConfig } from './normalizeToFieldConfig';
+export { getFieldsForOperation, type RenderableField, type GetFieldsForOperationOptions, type EntityFieldsInput, } from './getFieldsForOperation';
+export { createEntitySchema, type SchemaOperation } from './createEntitySchema';
+export { validateEntity, type ValidationIssue, type ValidationResult, } from './validateEntity';
+//# sourceMappingURL=index.d.ts.map

package/dist/forms/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/forms/utils/index.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,EAAE,eAAe,EAAE,KAAK,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EACL,qBAAqB,EACrB,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,iBAAiB,GACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,kBAAkB,EAAE,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAChF,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,kBAAkB,CAAC"}

package/dist/forms/utils/index.js

@@ -0,0 +1 @@
+import{isFieldEditable as r}from"./isFieldEditable";import{normalizeToFieldConfig as i}from"./normalizeToFieldConfig";import{getFieldsForOperation as m}from"./getFieldsForOperation";import{createEntitySchema as l}from"./createEntitySchema";import{validateEntity as d}from"./validateEntity";export{l as createEntitySchema,m as getFieldsForOperation,r as isFieldEditable,i as normalizeToFieldConfig,d as validateEntity};

package/dist/forms/utils/isFieldEditable.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @fileoverview Field editability utility
+ * @description Determines if a field is editable based on editable config, viewer role, and operation.
+ *
+ * @version 0.0.1
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+import type { Editable } from '@donotdev/core';
+/** Viewer role type - used for editability checks */
+export type ViewerRole = 'public' | 'guest' | 'user' | 'admin' | 'super';
+/**
+ * Determines if a field is editable by the current viewer.
+ *
+ * NOTE: Visibility is handled by backend - this function only handles editability (UI concern).
+ *
+ * @param editable - Field's editable configuration
+ * @param viewerRole - Current viewer's role
+ * @param operation - Form operation type
+ * @returns Whether the field should be rendered as an input (true) or read-only (false)
+ *
+ * @example
+ * ```typescript
+ * // Default editable
+ * isFieldEditable(undefined, 'user', 'create'); // true
+ *
+ * // Admin-only field
+ * isFieldEditable('admin', 'user', 'edit'); // false
+ * isFieldEditable('admin', 'admin', 'edit'); // true
+ *
+ * // Create-only field
+ * isFieldEditable('create-only', 'user', 'create'); // true
+ * isFieldEditable('create-only', 'user', 'edit'); // false
+ * ```
+ *
+ * @see {@link Editable} for editable configuration options
+ *
+ * @version 0.0.1
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+export declare function isFieldEditable(editable: Editable | undefined, viewerRole: ViewerRole, operation: 'create' | 'edit'): boolean;
+//# sourceMappingURL=isFieldEditable.d.ts.map

package/dist/forms/utils/isFieldEditable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isFieldEditable.d.ts","sourceRoot":"","sources":["../../../src/forms/utils/isFieldEditable.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C,qDAAqD;AACrD,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,QAAQ,GAAG,SAAS,EAC9B,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,QAAQ,GAAG,MAAM,GAC3B,OAAO,CAcT"}

package/dist/forms/utils/isFieldEditable.js

@@ -0,0 +1 @@
+import{hasRoleAccess as t,USER_ROLES as u}from"@donotdev/core";function i(r,e,n){return r===void 0||r===!0?!0:r===!1?!1:r==="admin"?t(e,u.ADMIN):r==="create-only"?n==="create":!0}export{i as isFieldEditable};

package/dist/forms/utils/normalizeToFieldConfig.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @fileoverview Field config normalization utility
+ * @description Converts EntityField (from defineEntity) to FieldConfig format used by form components.
+ * Preserves generic type parameter for type-safe form handling.
+ *
+ * @version 0.0.2
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+import type { FieldConfig, EntityField, FieldType } from '@donotdev/core';
+/**
+ * Normalizes EntityField to FieldConfig format, preserving type parameter.
+ *
+ * Handles conversion from entity definitions (defineEntity) to form-compatible format.
+ * If the field already has a `name` property (is already a FieldConfig), returns as-is.
+ *
+ * @template T - The field type, preserved from input for type-safe validation
+ * @param name - Field name/key from the entity definition
+ * @param field - Field definition (EntityField or FieldConfig)
+ * @returns Normalized FieldConfig ready for form rendering
+ *
+ * @example
+ * ```typescript
+ * // From EntityField (defineEntity output) - type is preserved
+ * const entityField: EntityField<'email'> = {
+ *   type: 'email',
+ *   visibility: 'user',
+ *   validation: { required: true }
+ * };
+ * const config = normalizeToFieldConfig('email', entityField);
+ * // FieldConfig<'email'> - TypeScript knows value type is string
+ *
+ * // Already a FieldConfig (passes through)
+ * const fieldConfig: FieldConfig<'text'> = { name: 'email', type: 'text', label: 'Email' };
+ * const config2 = normalizeToFieldConfig('email', fieldConfig);
+ * // Same as input, type preserved
+ * ```
+ *
+ * @see {@link EntityField} for entity field definition
+ * @see {@link FieldConfig} for form field configuration
+ *
+ * @version 0.0.2
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+export declare function normalizeToFieldConfig<T extends FieldType>(name: string, field: FieldConfig<T> | EntityField<T>): FieldConfig<T>;
+//# sourceMappingURL=normalizeToFieldConfig.d.ts.map

package/dist/forms/utils/normalizeToFieldConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeToFieldConfig.d.ts","sourceRoot":"","sources":["../../../src/forms/utils/normalizeToFieldConfig.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,SAAS,EACxD,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GACrC,WAAW,CAAC,CAAC,CAAC,CA2BhB"}

package/dist/forms/utils/normalizeToFieldConfig.js

@@ -0,0 +1 @@
+function n(t,e){if("name"in e&&typeof e.name=="string")return e;const i=e;return{name:t,type:i.type,label:i.label||t.charAt(0).toUpperCase()+t.slice(1).replace(/([A-Z])/g," $1"),required:i.validation?.required??!1,visibility:i.visibility,editable:i.editable,validation:i.validation,options:i.options,dependsOn:i.dependsOn,hint:i.hint,i18n:i.i18n,group:i.group}}export{n as normalizeToFieldConfig};

package/dist/forms/utils/validateEntity.d.ts

@@ -0,0 +1,77 @@
+import type { Entity } from '@donotdev/core';
+import { type SchemaOperation } from './createEntitySchema';
+/**
+ * Validation issue structure
+ */
+export interface ValidationIssue {
+    /** Field path (e.g., 'name' or 'address.street') */
+    path: string;
+    /** Error message */
+    message: string;
+}
+/**
+ * Validation result structure
+ * @template T - Data type
+ */
+export interface ValidationResult<T> {
+    /** Whether validation succeeded */
+    success: boolean;
+    /** Validated data (if success) */
+    data?: T;
+    /** Validation issues (if failed) */
+    issues?: ValidationIssue[];
+}
+/**
+ * Validates data against an entity definition.
+ *
+ * Uses Valibot under the hood with entity-derived schemas.
+ * Pure function, no React dependencies.
+ *
+ * @template E - Entity type from defineEntity()
+ * @param entity - Entity definition from defineEntity()
+ * @param data - Data to validate
+ * @param operation - Validation context ('create' or 'update')
+ * @returns Validation result with typed issues
+ *
+ * @example
+ * ```typescript
+ * import { validateEntity } from '@donotdev/crud/forms';
+ * import { productEntity } from './entities/product';
+ *
+ * // Validate create data
+ * const result = validateEntity(productEntity, formData, 'create');
+ *
+ * if (result.success) {
+ *   await saveProduct(result.data);
+ * } else {
+ *   console.error('Validation failed:', result.issues);
+ *   // [{ path: 'name', message: 'Required' }, ...]
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use in form submission
+ * const onSubmit = async (data: unknown) => {
+ *   const validation = validateEntity(productEntity, data, 'create');
+ *
+ *   if (!validation.success) {
+ *     validation.issues?.forEach(issue => {
+ *       form.setError(issue.path, { message: issue.message });
+ *     });
+ *     return;
+ *   }
+ *
+ *   await api.createProduct(validation.data);
+ * };
+ * ```
+ *
+ * @see {@link Entity} for entity definition structure
+ * @see {@link ValidationResult} for return type
+ *
+ * @version 0.0.1
+ * @since 0.0.1
+ * @author AMBROISE PARK Consulting
+ */
+export declare function validateEntity<E extends Entity>(entity: E, data: unknown, operation?: SchemaOperation): ValidationResult<Record<string, unknown>>;
+//# sourceMappingURL=validateEntity.d.ts.map

package/dist/forms/utils/validateEntity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateEntity.d.ts","sourceRoot":"","sources":["../../../src/forms/utils/validateEntity.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEhF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,kCAAkC;IAClC,IAAI,CAAC,EAAE,CAAC,CAAC;IACT,oCAAoC;IACpC,MAAM,CAAC,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAC7C,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,OAAO,EACb,SAAS,GAAE,eAA0B,GACpC,gBAAgB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAsB3C"}

package/dist/forms/utils/validateEntity.js

@@ -0,0 +1 @@
+import*as o from"valibot";import{createEntitySchema as i}from"./createEntitySchema";function p(t,a,c="create"){const r=i(t,c),s=o.safeParse(r,a);return s.success?{success:!0,data:s.output}:{success:!1,issues:s.issues.map(e=>({path:e.path?.map(u=>u.key).join(".")||"",message:e.message}))}}export{p as validateEntity};

package/dist/index.d.ts

@@ -2,7 +2,7 @@
  * @fileoverview CRUD package
  * @description CRUD operations and form components for DoNotDev framework
  *
- * @version 0.0.1
+ * @version 0.0.2
  * @since 0.0.1
  * @author AMBROISE PARK Consulting
  */
@@ -10,4 +10,7 @@ export * from './useCrud';
 export * from './components';
 export { getCrudService } from './CrudService';
 export { loadDeterministicRange, upsertDeterministic, appendToCollection, } from './utils/collections';
+export { getFieldRegistry, registerFieldType, isFieldTypeRegistered, type FieldTypeRegistration, type SchemaGenerator, type ControlledFieldProps, type UncontrolledFieldProps, } from './FieldRegistry';
+export { useEntityForm, useEntityField, isFieldEditable, normalizeToFieldConfig, getFieldsForOperation, createEntitySchema, validateEntity, } from './forms';
+export type { ViewerRole, RenderableField, GetFieldsForOperationOptions, EntityFieldsInput, SchemaOperation, ValidationIssue, ValidationResult, InferEntityData, InferEntityInput, InferEntityOutput, UseEntityFormOptions, EntityFormReturn, EntityFieldReturn, } from './forms';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAGH,cAAc,WAAW,CAAC;AAG1B,cAAc,cAAc,CAAC;AAG7B,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAG/C,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EACL,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAEL,aAAa,EACb,cAAc,EAEd,eAAe,EACf,sBAAsB,EACtB,qBAAqB,EACrB,kBAAkB,EAClB,cAAc,GACf,MAAM,SAAS,CAAC;AAGjB,YAAY,EACV,UAAU,EACV,eAAe,EACf,4BAA4B,EAC5B,iBAAiB,EACjB,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,eAAe,EACf,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1 +1 @@
-export*from"./useCrud";export*from"./components";import{getCrudService as e}from"./CrudService";import{loadDeterministicRange as i,upsertDeterministic as r,appendToCollection as t}from"./utils/collections";export{t as appendToCollection,e as getCrudService,i as loadDeterministicRange,r as upsertDeterministic};
+export*from"./useCrud";export*from"./components";import{getCrudService as d}from"./CrudService";import{loadDeterministicRange as m,upsertDeterministic as n,appendToCollection as s}from"./utils/collections";import{getFieldRegistry as F,registerFieldType as g,isFieldTypeRegistered as f}from"./FieldRegistry";import{useEntityForm as c,useEntityField as x,isFieldEditable as u,normalizeToFieldConfig as E,getFieldsForOperation as T,createEntitySchema as C,validateEntity as R}from"./forms";import{registerBuiltinFieldTypes as e}from"./builtinFieldTypes";e();export{s as appendToCollection,C as createEntitySchema,d as getCrudService,F as getFieldRegistry,T as getFieldsForOperation,u as isFieldEditable,f as isFieldTypeRegistered,m as loadDeterministicRange,E as normalizeToFieldConfig,g as registerFieldType,n as upsertDeterministic,x as useEntityField,c as useEntityForm,R as validateEntity};