@tempots/beatui 0.17.0 → 0.19.0

package/dist/types/components/form/use-form.d.ts

@@ -1,20 +1,26 @@
+import { Signal, Value } from '@tempots/dom';
 import { StandardSchemaV1 } from './schema/standard-schema-v1';
 import { ControllerValidation, Controller, ObjectController } from './controller';
 export interface UseFormOptions<T> {
     schema: StandardSchemaV1<T, T>;
-    defaultValue?: T;
+    initialValue?: Value<T>;
     submit?: (value: T) => Promise<ControllerValidation>;
+    validationMode?: 'onSubmit' | 'continuous' | 'touchedOrSubmit';
+    validateDebounceMs?: number;
 }
 export interface UseControllerOptions<T> {
-    defaultValue: T;
+    initialValue: Value<T>;
     onChange?: (value: T) => void;
     validate?: (value: T) => Promise<ControllerValidation> | ControllerValidation;
+    equals?: (a: T, b: T) => boolean;
+    validationMode?: 'onSubmit' | 'continuous' | 'touchedOrSubmit';
+    validateDebounceMs?: number;
 }
 /**
  * Creates a Controller instance with automatic resource cleanup.
  * The controller will be automatically disposed when the component unmounts.
  */
-export declare function useController<T>({ defaultValue, onChange, validate, }: UseControllerOptions<T>): {
+export declare function useController<T>({ initialValue, onChange, validate, equals, validationMode, validateDebounceMs, }: UseControllerOptions<T>): {
     controller: Controller<T>;
     setStatus: (result: ControllerValidation) => void;
 };
@@ -54,5 +60,6 @@ export type UseFormResult<T> = {
     controller: ObjectController<T>;
     setStatus: (result: ControllerValidation) => void;
     onSubmit: (e: Event) => Promise<void>;
+    submitting: Signal<boolean>;
 };
-export declare function useForm<T>({ defaultValue, schema, submit, }: UseFormOptions<T>): UseFormResult<T>;
+export declare function useForm<T>({ initialValue, schema, submit, validationMode, validateDebounceMs, }: UseFormOptions<T>): UseFormResult<T>;

package/dist/types/components/json-schema/ajv-utils.d.ts

@@ -0,0 +1,121 @@
+import type Ajv from 'ajv';
+import type { ErrorObject, ValidateFunction } from 'ajv';
+import type { SchemaObject } from 'ajv';
+import type { ControllerError, ControllerValidation } from '../form';
+export declare function jsonPointerToSegments(ptr: string): PropertyKey[];
+export declare function buildPath(err: ErrorObject): ReadonlyArray<PropertyKey> | undefined;
+export declare function buildMessage(err: ErrorObject): string;
+export declare function ajvErrorsToDependencies(errors: ErrorObject[]): ControllerError;
+export declare function ajvErrorsToControllerValidation(errors: ErrorObject[]): ControllerValidation;
+/**
+ * Clear all AJV compilation caches. Useful for:
+ * - Test isolation (call in beforeEach)
+ * - Memory management in long-running applications
+ * - Forcing recompilation after schema changes
+ *
+ * Thread-safe: Uses WeakMap reassignment for atomic clearing.
+ */
+export declare function clearCaches(): void;
+/**
+ * Clear caches for a specific AJV instance.
+ * Useful when you want to invalidate only schemas compiled with a particular AJV instance
+ * while preserving caches for other instances.
+ */
+export declare function clearCachesForAjv(ajv: Ajv): void;
+/**
+ * Get cache statistics for debugging and monitoring.
+ * Returns the number of AJV instances with cached validators.
+ */
+export declare function getCacheStats(): {
+    ajvInstances: number;
+};
+/**
+ * Compile a JSON Schema with caching for performance optimization.
+ *
+ * Uses a two-level WeakMap cache structure:
+ * - Level 1: AJV instance -> Schema cache map
+ * - Level 2: Schema object -> Compiled ValidateFunction
+ *
+ * This ensures that:
+ * - Same schema compiled with same AJV instance is cached
+ * - Different AJV instances maintain separate caches
+ * - Memory is automatically cleaned up when objects are garbage collected
+ *
+ * @param ajv - The AJV instance to use for compilation
+ * @param schema - The schema object to compile (must be object identity stable)
+ * @returns Cached or newly compiled ValidateFunction
+ */
+export declare function compileWithCache(ajv: Ajv, schema: object): ValidateFunction;
+/**
+ * Result type for AJV instance creation and schema compilation.
+ * Uses discriminated union for type-safe error handling.
+ */
+export type BuildAjvResult = {
+    ok: true;
+    value: {
+        ajv: Ajv;
+        validate: import('ajv').ValidateFunction;
+    };
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Configuration options for building AJV instances with external reference support.
+ */
+export interface AjvBuildOptions {
+    /**
+     * Pre-bundled external schemas to register with AJV.
+     * These schemas must have $id properties for reference resolution.
+     */
+    externalSchemas?: ReadonlyArray<SchemaObject>;
+    /**
+     * Dynamic resolver for external $ref URIs.
+     * Called when external references are encountered during compilation.
+     */
+    refResolver?: (ids: ReadonlyArray<string>) => Promise<ReadonlyArray<SchemaObject>>;
+    /**
+     * Controls automatic removal of additional properties during validation.
+     * - 'all': Remove all additional properties
+     * - 'failing': Remove only properties that cause validation failures
+     * - false: No automatic removal (default)
+     */
+    sanitizeAdditional?: 'all' | 'failing' | false;
+}
+/**
+ * Create and configure an AJV instance for a specific JSON Schema with external reference support.
+ *
+ * This is the primary entry point for creating AJV instances in the JSON Schema form system.
+ * It handles:
+ * - Automatic JSON Schema draft detection ($schema property)
+ * - Pre-bundled external schema registration
+ * - Dynamic external reference resolution via refResolver
+ * - Compilation caching for performance
+ * - Error handling with detailed messages
+ *
+ * @param schema - The root JSON Schema to compile. Must be a valid JSON Schema object.
+ *                 The $schema property determines which AJV version to use.
+ * @param options - Configuration for external references and sanitization
+ * @returns Promise resolving to either a successful AJV instance with compiled validator,
+ *          or an error result with descriptive message
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const result = await getAjvForSchema(mySchema)
+ * if (result.ok) {
+ *   const { ajv, validate } = result.value
+ *   const isValid = validate(data)
+ * }
+ *
+ * // With external schemas
+ * const result = await getAjvForSchema(mySchema, {
+ *   externalSchemas: [addressSchema, personSchema],
+ *   refResolver: async (ids) => await fetchSchemas(ids)
+ * })
+ * ```
+ */
+export declare function getAjvForSchema(schema: {
+    $schema?: string;
+    $id?: string;
+} & SchemaObject, options?: AjvBuildOptions): Promise<BuildAjvResult>;

package/dist/types/components/json-schema/cache-management.d.ts

@@ -0,0 +1,148 @@
+/**
+ * Cache Management and Lifetime Boundaries for JSON Schema Form System
+ *
+ * This module defines the caching strategy and lifetime boundaries for the JSON Schema
+ * form system, ensuring optimal performance while maintaining thread safety and memory efficiency.
+ */
+import type { Ajv } from 'ajv';
+/**
+ * CACHING ARCHITECTURE DECISIONS:
+ *
+ * 1. AJV Instance Lifetime:
+ *    - Each form creates its own AJV instance via getAjvForSchema()
+ *    - AJV instances are NOT shared between forms to avoid:
+ *      * Schema pollution (one form's schemas affecting another)
+ *      * Concurrency issues in multi-threaded environments
+ *      * Complex cache invalidation when schemas change
+ *
+ * 2. Validator Compilation Cache:
+ *    - Keyed by: AJV instance -> Schema object identity
+ *    - Lifetime: Lives as long as the AJV instance exists
+ *    - Thread-safe: Uses WeakMap for automatic cleanup
+ *    - Scope: Per-AJV instance (form-level isolation)
+ *
+ * 3. $ref Resolution Cache:
+ *    - Keyed by: Root schema object -> Definition object
+ *    - Lifetime: Lives as long as the root schema exists
+ *    - Thread-safe: Uses WeakMap for automatic cleanup
+ *    - Scope: Global (shared across forms for efficiency)
+ *
+ * 4. External Schema Cache:
+ *    - Managed by AJV's internal addSchema() mechanism
+ *    - Lifetime: Per-AJV instance
+ *    - Scope: Form-level (each form has its own external schemas)
+ */
+export interface CacheManagementOptions {
+    /**
+     * Whether to clear all caches on initialization.
+     * Useful for testing or when you want a clean slate.
+     */
+    clearOnInit?: boolean;
+    /**
+     * Whether to enable automatic cache cleanup.
+     * When true, caches are cleared when forms are disposed.
+     */
+    autoCleanup?: boolean;
+}
+/**
+ * Comprehensive cache clearing for all JSON Schema form caches.
+ * This is the primary cache management function that should be used
+ * for test isolation and memory management.
+ *
+ * WHEN TO USE:
+ * - In test beforeEach/afterEach hooks
+ * - When switching between different schema sets
+ * - For memory management in long-running applications
+ * - When you suspect cache corruption
+ */
+export declare function clearAllCaches(): void;
+/**
+ * Clear caches for a specific AJV instance only.
+ * This provides fine-grained cache control when you want to
+ * invalidate only one form's caches.
+ *
+ * WHEN TO USE:
+ * - When a specific form's schema changes
+ * - For targeted memory cleanup
+ * - When debugging cache-related issues in a specific form
+ */
+export declare function clearCachesForForm(ajv: Ajv): void;
+/**
+ * Cache statistics and debugging information.
+ * Useful for monitoring cache effectiveness and debugging performance issues.
+ */
+export interface CacheStats {
+    /** Number of AJV instances with cached validators (approximate) */
+    ajvInstances: number;
+    /** Whether caches are enabled */
+    enabled: boolean;
+    /** Cache implementation details */
+    implementation: {
+        validatorCache: 'WeakMap<Ajv, WeakMap<object, ValidateFunction>>';
+        refCache: 'WeakMap<object, WeakMap<object, JSONSchema>>';
+        pointerCache: 'WeakMap<object, Map<string, unknown>>';
+    };
+}
+/**
+ * Get comprehensive cache statistics for monitoring and debugging.
+ */
+export declare function getCacheStats(): CacheStats;
+/**
+ * THREAD SAFETY GUARANTEES:
+ *
+ * 1. WeakMap Operations:
+ *    - All cache operations use WeakMaps which are thread-safe for reads
+ *    - Cache clearing uses atomic WeakMap reassignment
+ *    - No explicit locking required
+ *
+ * 2. AJV Instance Isolation:
+ *    - Each form gets its own AJV instance
+ *    - No shared mutable state between forms
+ *    - External schema registration is per-instance
+ *
+ * 3. Memory Management:
+ *    - WeakMaps automatically cleanup when objects are garbage collected
+ *    - No manual memory management required in normal operation
+ *    - clearAllCaches() provides explicit cleanup for testing/debugging
+ */
+/**
+ * PERFORMANCE CHARACTERISTICS:
+ *
+ * 1. Cache Hit Performance:
+ *    - O(1) lookup for compiled validators
+ *    - O(1) lookup for resolved $refs
+ *    - Minimal overhead for cache checks
+ *
+ * 2. Cache Miss Performance:
+ *    - AJV compilation: ~1-10ms per schema (depends on complexity)
+ *    - $ref resolution: ~0.1-1ms per reference
+ *    - External schema loading: Network-dependent
+ *
+ * 3. Memory Usage:
+ *    - Compiled validators: ~1-10KB per schema
+ *    - Resolved refs: ~100B-1KB per reference
+ *    - Automatic cleanup via WeakMap garbage collection
+ */
+/**
+ * RECOMMENDED USAGE PATTERNS:
+ *
+ * 1. Production Applications:
+ *    - Let caches accumulate naturally
+ *    - Use clearAllCaches() only for memory pressure
+ *    - Monitor via getCacheStats() if needed
+ *
+ * 2. Testing:
+ *    - Call clearAllCaches() in beforeEach hooks
+ *    - Ensures test isolation
+ *    - Prevents cache-related test flakiness
+ *
+ * 3. Development:
+ *    - Use clearCachesForForm() when schema changes
+ *    - Call clearAllCaches() when switching projects
+ *    - Monitor cache stats for performance debugging
+ */
+export declare const CacheManagement: {
+    readonly clearAll: typeof clearAllCaches;
+    readonly clearForForm: typeof clearCachesForForm;
+    readonly getStats: typeof getCacheStats;
+};

package/dist/types/components/json-schema/containers/container-layouts.d.ts

@@ -0,0 +1,66 @@
+import { Renderable, TNode } from '@tempots/dom';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Container layout configuration from x:ui
+ */
+export interface ContainerLayoutConfig {
+    /** Container format type */
+    format?: 'fieldset' | 'tabs' | 'accordion' | 'group' | 'grid';
+    /** Property ordering */
+    order?: string[];
+    /** Property grouping */
+    groups?: Record<string, string[]>;
+    /** Grid columns configuration */
+    cols?: number | {
+        sm?: number;
+        md?: number;
+        lg?: number;
+        xl?: number;
+        '2xl'?: number;
+    };
+    /** Additional layout options */
+    [key: string]: unknown;
+}
+/**
+ * Extract container layout configuration from schema x:ui
+ */
+export declare function getContainerLayout(ctx: SchemaContext): ContainerLayoutConfig | undefined;
+/**
+ * Fieldset container layout
+ */
+export declare function FieldsetContainer({ title, children, }: {
+    title?: string;
+    children: TNode[];
+}): Renderable;
+/**
+ * Group container layout (using Card)
+ */
+export declare function GroupContainer({ title, children, }: {
+    title?: string;
+    children: TNode[];
+}): Renderable;
+/**
+ * Grid container layout
+ */
+export declare function GridContainer({ cols, children, }: {
+    cols?: ContainerLayoutConfig['cols'];
+    children: TNode[];
+}): Renderable;
+/**
+ * Tabs container layout
+ */
+export declare function TabsContainer({ groups, children, }: {
+    groups?: Record<string, TNode[]>;
+    children: TNode[];
+}): Renderable;
+/**
+ * Accordion container layout
+ */
+export declare function AccordionContainer({ groups, children, }: {
+    groups?: Record<string, TNode[]>;
+    children: TNode[];
+}): Renderable;
+/**
+ * Apply container layout to children based on configuration
+ */
+export declare function applyContainerLayout(config: ContainerLayoutConfig | undefined, ctx: SchemaContext, children: TNode[], propertyNames?: string[]): Renderable;

package/dist/types/components/json-schema/controls/any-control.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for any/unknown type schemas
+ */
+export declare function JSONSchemaAny({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<unknown>;
+}): Renderable;

package/dist/types/components/json-schema/controls/array-control.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '@tempots/dom';
+import { type ArrayController } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for array schemas with tuple support
+ */
+export declare function JSONSchemaArray({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: ArrayController<unknown[]>;
+}): Renderable;

package/dist/types/components/json-schema/controls/boolean-control.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '@tempots/dom';
+import { type Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for boolean schemas
+ */
+export declare function JSONSchemaBoolean({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<boolean | null>;
+}): Renderable;

package/dist/types/components/json-schema/controls/composition-controls.d.ts

@@ -0,0 +1,24 @@
+import { Renderable } from '@tempots/dom';
+import type { SchemaContext } from '../schema-context';
+import type { Controller } from '../../form';
+/**
+ * Control for anyOf schemas
+ */
+export declare function JSONSchemaAnyOf<T>({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<T>;
+}): Renderable;
+/**
+ * Control for oneOf schemas
+ */
+export declare function JSONSchemaOneOf<T>({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<T>;
+}): Renderable;
+/**
+ * Control for allOf schemas
+ */
+export declare function JSONSchemaAllOf<T>({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<T>;
+}): Renderable;

package/dist/types/components/json-schema/controls/composition-shared.d.ts

@@ -0,0 +1,34 @@
+import { Renderable, Value } from '@tempots/dom';
+import type { SchemaContext } from '../schema-context';
+export type ChoiceMode = 'auto' | 'segmented' | 'select';
+export interface ChoiceOption<T extends string | number> {
+    value: T;
+    label: string;
+}
+export interface ChoiceSelectorParams<T extends string | number> {
+    options: ReadonlyArray<ChoiceOption<T>>;
+    selected: Value<T>;
+    onChange: (value: T) => void;
+    mode?: ChoiceMode;
+    size?: 'sm' | 'md' | 'lg';
+    keyFor?: (value: T) => string;
+    parseKey?: (key: string) => T;
+}
+/**
+ * Build a selector UI that automatically chooses SegmentedInput (<=3 options)
+ * or NativeSelect (>3 options), with optional explicit override.
+ * Works with both string and number choices via keyFor/parseKey.
+ */
+export declare function ChoiceSelector<T extends string | number>(params: ChoiceSelectorParams<T>): Renderable;
+export interface WithSelectorLayoutParams {
+    ctx: SchemaContext;
+    showSelector: boolean;
+    selector: Renderable;
+    inner: Renderable;
+}
+/**
+ * Wrap inner control with selector and layout based on context.
+ * - At root: show selector + inner in a vertical Stack when showSelector is true
+ * - Non-root: wrap content in InputWrapper and include selector when needed
+ */
+export declare function WithSelectorLayout({ ctx, showSelector, selector, inner, }: WithSelectorLayoutParams): Renderable;

package/dist/types/components/json-schema/controls/enum-const-controls.d.ts

@@ -0,0 +1,17 @@
+import { Renderable } from '@tempots/dom';
+import { type Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for enum schemas
+ */
+export declare function JSONSchemaEnum({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<unknown>;
+}): Renderable;
+/**
+ * Control for const schemas
+ */
+export declare function JSONSchemaConst({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<unknown>;
+}): Renderable;

package/dist/types/components/json-schema/controls/generic-control.d.ts

@@ -0,0 +1,18 @@
+import { Renderable } from '@tempots/dom';
+import { type Controller } from '../../form';
+import type { SchemaContext, JSONSchemaDefinition } from '../schema-context';
+/**
+ * Generic control dispatcher that routes to appropriate control based on schema
+ */
+export declare function JSONSchemaGenericControl<T>({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<T>;
+}): Renderable;
+/**
+ * Main entry point for JSON Schema controls
+ */
+export declare function JSONSchemaControl<T>({ schema, controller, ajv, }: {
+    schema: JSONSchemaDefinition;
+    controller: Controller<T>;
+    ajv?: import('ajv').default;
+}): Renderable;

package/dist/types/components/json-schema/controls/null-control.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for null schemas
+ */
+export declare function JSONSchemaNull({ controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<null>;
+}): Renderable;

package/dist/types/components/json-schema/controls/number-controls.d.ts

@@ -0,0 +1,17 @@
+import { Renderable } from '@tempots/dom';
+import { type Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for number schemas
+ */
+export declare function JSONSchemaNumber({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<number>;
+}): Renderable;
+/**
+ * Control for integer schemas
+ */
+export declare function JSONSchemaInteger({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<number>;
+}): Renderable;

package/dist/types/components/json-schema/controls/object-control.d.ts

@@ -0,0 +1,12 @@
+import { Renderable } from '@tempots/dom';
+import { ObjectController } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for object schemas
+ */
+export declare function JSONSchemaObject({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: ObjectController<{
+        [key: string]: unknown;
+    }>;
+}): Renderable;

package/dist/types/components/json-schema/controls/object-helpers.d.ts

@@ -0,0 +1,31 @@
+import { Renderable } from '@tempots/dom';
+import { ObjectController } from '../../form';
+import type { SchemaContext, JSONSchema, JSONSchemaDefinition } from '../schema-context';
+interface RenderEntryOptions {
+    controller: ObjectController<{
+        [key: string]: unknown;
+    }>;
+    effCtx: SchemaContext;
+    patternProps: Record<string, JSONSchemaDefinition>;
+    apSchema: JSONSchema;
+    canRemove: (count: number) => boolean;
+    lockKeyAfterSet: boolean;
+    validatePropertyName: (name: string) => {
+        ok: true;
+    } | {
+        ok: false;
+        message: string;
+    };
+}
+interface RenderUnevaluatedEntryOptions extends RenderEntryOptions {
+    unevaluatedProps: boolean | JSONSchema | undefined;
+}
+/**
+ * Render an additional property entry
+ */
+export declare function renderAdditionalEntry(key: string, usePatternSchema: boolean, options: RenderEntryOptions): Renderable;
+/**
+ * Render an unevaluated property entry
+ */
+export declare function renderUnevaluatedEntry(key: string, usePatternSchema: boolean, options: RenderUnevaluatedEntryOptions): Renderable;
+export {};

package/dist/types/components/json-schema/controls/presence-toggle.d.ts

@@ -0,0 +1,12 @@
+import { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Presence toggle for optional properties.
+ * Shows a toggle that controls whether the property key exists in the parent object.
+ */
+export declare function PresenceToggle<T>({ ctx, controller, content, }: {
+    ctx: SchemaContext;
+    controller: Controller<T>;
+    content: Renderable;
+}): Renderable;

package/dist/types/components/json-schema/controls/schema-banners.d.ts

@@ -0,0 +1,14 @@
+import { Renderable } from '@tempots/dom';
+import type { SchemaConflict, NotViolation } from '../schema-context';
+/**
+ * Banner component for displaying schema conflicts
+ */
+export declare function SchemaConflictsBanner({ conflicts, }: {
+    conflicts: readonly SchemaConflict[];
+}): Renderable;
+/**
+ * Banner component for displaying schema violations
+ */
+export declare function NotViolationsBanner({ violations, }: {
+    violations: readonly NotViolation[];
+}): Renderable;

package/dist/types/components/json-schema/controls/schema-wrapper.d.ts

@@ -0,0 +1,7 @@
+import { Renderable } from '@tempots/dom';
+import type { Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Wraps content with schema issues banners and presence toggle if needed
+ */
+export declare function WithSchemaIssues<T>(ctx: SchemaContext, content: Renderable, controller?: Controller<T>): Renderable;

package/dist/types/components/json-schema/controls/shared-utils.d.ts

@@ -0,0 +1,16 @@
+import type { JSONSchema } from '../schema-context';
+import type { InputWrapperOptions } from '../../form';
+/**
+ * Convert schema definition to input wrapper options
+ */
+export declare function definitionToInputWrapperOptions({ ctx, }: {
+    ctx: import('../schema-context').SchemaContext;
+}): Partial<InputWrapperOptions>;
+/**
+ * Create placeholder value from schema definition
+ */
+export declare function makePlaceholder<T>(definition: JSONSchema, converter: (value: unknown) => T): T | undefined;
+/**
+ * Convert multipleOf to integer step for integer inputs
+ */
+export declare function integerMultipleOf(multipleOf?: number): number;

package/dist/types/components/json-schema/controls/string-control.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '@tempots/dom';
+import { type Controller } from '../../form';
+import type { SchemaContext } from '../schema-context';
+/**
+ * Control for string schemas
+ */
+export declare function JSONSchemaString({ ctx, controller, }: {
+    ctx: SchemaContext;
+    controller: Controller<string | undefined>;
+}): Renderable;