@akad/form-builder 1.0.0

package/components/FormBuilder/utils/schemaUtils.d.ts

@@ -0,0 +1,113 @@
+import { UISchemaField } from '../FormBuilder.config';
+/**
+ * Resolve UI config from nested or flat UISchema
+ * @description Supports BOTH flat dot notation and nested object notation
+ * @param fieldPath Field path (e.g., "insured.name" or "email")
+ * @param uiSchema UI Schema object to search in
+ * @returns UISchemaField configuration or empty object if not found
+ * @example
+ * ```ts
+ * // Flat notation
+ * resolveUIConfig('insured.name', { 'insured.name': { 'ui:component': 'Input' } })
+ * // Returns { 'ui:component': 'Input' }
+ *
+ * // Nested notation
+ * resolveUIConfig('insured.name', { insured: { name: { 'ui:component': 'Input' } } })
+ * // Returns { 'ui:component': 'Input' }
+ * ```
+ */
+export declare const resolveUIConfig: (fieldPath: string, uiSchema: Record<string, unknown>) => UISchemaField;
+/**
+ * Flatten nested schema properties into dot notation paths
+ * @description Recursively extracts all fields from nested object schemas into flat paths
+ * @param properties Schema properties object
+ * @param prefix Current path prefix for nested fields
+ * @param parentRequired Parent required array for tracking required status
+ * @returns Array of [fieldPath, fieldSchema, isRequired] tuples
+ * @example
+ * ```ts
+ * flattenSchemaProperties({
+ *   name: { type: 'string' },
+ *   address: {
+ *     type: 'object',
+ *     properties: {
+ *       city: { type: 'string' }
+ *     }
+ *   }
+ * })
+ * // Returns [
+ * //   ['name', { type: 'string' }, false],
+ * //   ['address.city', { type: 'string' }, false]
+ * // ]
+ * ```
+ */
+export declare const flattenSchemaProperties: (properties: Record<string, unknown>, prefix?: string, parentRequired?: string[]) => Array<[string, Record<string, unknown>, boolean]>;
+/**
+ * Flatten nested UISchema children to dot notation
+ * @description Converts nested object notation to flat dot notation in wrapper children
+ * @param children Children object from wrapper ui:props.children
+ * @param prefix Current path prefix for nested fields
+ * @returns Flattened children with dot notation keys
+ * @example
+ * ```ts
+ * flattenUISchemaChildren({
+ *   title: { 'ui:component': 'DsHeading' },
+ *   PEP: {
+ *     isPep: { 'ui:component': 'RadioGroup' }
+ *   },
+ *   insured: {
+ *     document: { 'ui:component': 'Input' },
+ *     name: { 'ui:component': 'Input' }
+ *   }
+ * })
+ * // Returns {
+ * //   title: { 'ui:component': 'DsHeading' },
+ * //   'PEP.isPep': { 'ui:component': 'RadioGroup' },
+ * //   'insured.document': { 'ui:component': 'Input' },
+ * //   'insured.name': { 'ui:component': 'Input' }
+ * // }
+ * ```
+ */
+export declare const flattenUISchemaChildren: (children: Record<string, unknown>, prefix?: string) => Record<string, unknown>;
+/**
+ * Get the specific field object at a given path
+ * @description Navigates to the specified path and returns the field object directly (not wrapped in a key).
+ * Supports both flat object notation and JSON Schema format (with properties key).
+ * @param path Dot-notation path to navigate (e.g., "insured.address.number")
+ * @param obj Object to navigate through
+ * @returns The field object directly, or empty object if path doesn't exist
+ * @example
+ * ```ts
+ * // Flat notation
+ * getObjectAtPath('insured.address.number', {
+ *   insured: {
+ *     address: {
+ *       number: { type: 'string', minLength: 1 },
+ *       street: { type: 'string' }
+ *     }
+ *   }
+ * })
+ * // Returns { type: 'string', minLength: 1 }
+ *
+ * // JSON Schema notation
+ * getObjectAtPath('insured.address.number', {
+ *   type: 'object',
+ *   properties: {
+ *     insured: {
+ *       type: 'object',
+ *       properties: {
+ *         address: {
+ *           type: 'object',
+ *           properties: {
+ *             number: { type: 'string', minLength: 1 },
+ *             street: { type: 'string' }
+ *           }
+ *         }
+ *       }
+ *     }
+ *   }
+ * })
+ * // Returns { type: 'string', minLength: 1 }
+ * ```
+ */
+export declare const getObjectAtPath: (path: string, obj: Record<string, unknown>) => Record<string, unknown>;

package/components/FormBuilder/utils/schemaUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/typeCoercion.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Get schema properties for a field path
+ * @description Navigates through nested schema properties using dot notation
+ * @param path Dot notation path to field (e.g., "user.address.city")
+ * @param rootSchema Root JSON Schema object
+ * @returns Schema properties for the field or null if not found
+ * @example
+ * ```ts
+ * const schema = {
+ *   properties: {
+ *     user: {
+ *       type: 'object',
+ *       properties: {
+ *         name: { type: 'string' }
+ *       }
+ *     }
+ *   }
+ * };
+ * getSchemaProperties('user.name', schema); // Returns { type: 'string' }
+ * ```
+ */
+export declare function getSchemaProperties(path: string, rootSchema: Record<string, unknown>): Record<string, unknown> | null;
+/**
+ * Coerce value to correct type based on schema
+ * @description Converts string values to their proper types (boolean, number, integer)
+ * based on JSON Schema type definition
+ * @param value Value to coerce (typically a string from HTML form elements)
+ * @param schemaProps Schema properties containing type information
+ * @returns Coerced value with correct type
+ * @example
+ * ```ts
+ * coerceType('true', { type: 'boolean' }); // Returns true
+ * coerceType('42', { type: 'number' }); // Returns 42
+ * coerceType('hello', { type: 'string' }); // Returns 'hello' (unchanged)
+ * ```
+ */
+export declare function coerceType(value: unknown, schemaProps: Record<string, unknown>): unknown;
+/**
+ * Coerce field value based on JSON Schema
+ * @description Main utility function that looks up field schema and coerces value
+ * @param fieldPath Dot notation path to field
+ * @param value Value to coerce
+ * @param schema Root JSON Schema object
+ * @returns Coerced value with correct type
+ * @example
+ * ```ts
+ * const schema = {
+ *   properties: {
+ *     isActive: { type: 'boolean' },
+ *     age: { type: 'number' }
+ *   }
+ * };
+ * coerceFieldValue('isActive', 'true', schema); // Returns true
+ * coerceFieldValue('age', '25', schema); // Returns 25
+ * ```
+ */
+export declare function coerceFieldValue(fieldPath: string, value: unknown, schema: Record<string, unknown>): unknown;

package/components/FormBuilder/utils/typeCoercion.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/index.d.ts

@@ -0,0 +1,2 @@
+export * from './FormBuilder';
+export * from './FormBuilder/utils/facade';

package/main.d.ts

@@ -0,0 +1 @@
+export * from './components/index';

package/main.test.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@akad/form-builder",
+  "version": "1.0.0",
+  "main": "./react-lib.umd.cjs",
+  "module": "./react-lib.js",
+  "exports": {
+    ".": {
+      "import": "./react-lib.js",
+      "require": "./react-lib.umd.cjs"
+    }
+  },
+  "types": "./main.d.ts"
+}

package/react-lib.css

@@ -0,0 +1 @@
+.ds-radio-group{display:block;width:100%}.ds-radio-group__error{display:block;margin-top:.25rem;font-size:.875rem;color:var(--ds-color-danger-500, #dc3545)}