@ngx-formbar/core 1.0.0 → 2.0.0-next.1

package/types/ngx-formbar-core.d.ts

@@ -0,0 +1,525 @@
+import * as i0 from '@angular/core';
+import { Type, Signal, InjectionToken } from '@angular/core';
+import { Program } from 'acorn';
+import * as _ngx_formbar_core from '@ngx-formbar/core';
+
+/**
+ * Function that lazily loads a component.
+ * Works analog to lazily loading a component for a route.
+ */
+type LoadComponentFn = () => Promise<Type<unknown>>;
+/**
+ * Registration entry for a statically imported component.
+ */
+interface StaticRegistration {
+    component: Type<unknown>;
+}
+/**
+ * Registration entry for a lazily loaded component.
+ */
+interface LazyRegistration {
+    loadComponent: LoadComponentFn;
+}
+/**
+ * A component registration entry — either static or lazy.
+ *
+ * - Static: `{ component: MyComponent }` — component is eagerly imported
+ * - Lazy: `{ loadComponent: () => import(...).then(m => m.MyComponent) }` — loaded on demand
+ */
+type ComponentRegistrationEntry = StaticRegistration | LazyRegistration;
+/**
+ * Configuration for registering component types.
+ *
+ * Maps string type identifiers to component implementations for dynamic rendering.
+ * Supports both static and lazy component registrations.
+ */
+type ComponentRegistrationConfig = Record<string, ComponentRegistrationEntry>;
+/**
+ * Strategy for handling component states
+ *
+ * Determines how visibility, disabled, and other component states
+ * are managed.
+ *
+ * - 'auto': Formbar automatically manages the state
+ * - 'manual': The component/host manages the state itself
+ */
+type StateHandling = 'auto' | 'manual';
+
+interface ComponentResolver {
+    registrations: Signal<ReadonlyMap<string, ComponentRegistrationEntry>>;
+}
+
+type FormContext = Record<string, unknown>;
+type Expression<T> = string | ((formValue: FormContext) => T);
+
+/**
+ * The foundation for all form controls and groups. It defines the minimal set of
+ * properties shared across all content types: type identification and visibility.
+ */
+interface NgxFbBaseContent {
+    /**
+     * Specifies the kind of form control. Determines what control is used and what
+     * additional properties are available.
+     */
+    type: string;
+    /**
+     * A string expression that determines when the control should be hidden.
+     * This condition is evaluated at runtime against the whole form object.
+     */
+    hidden?: Expression<boolean>;
+}
+/**
+ * Extends the base content with validation and control state management properties.
+ * Used as a base for both form controls and groups.
+ */
+interface NgxFbAbstractControl extends NgxFbBaseContent {
+    /**
+     * Array of strings representing names of synchronous validators that apply to the control.
+     * These can be registered globally with a validator registration object.
+     */
+    validators?: string[];
+    /**
+     * Similar to validators, but for asynchronous validation logic that may involve
+     * API calls or other deferred operations.
+     */
+    asyncValidators?: string[];
+    /**
+     * Defines whether the control should be disabled. Can be a boolean value or a
+     * string expression that evaluates against the form object.
+     */
+    disabled?: Expression<boolean> | boolean;
+    /**
+     * Specifies how to handle the control when hidden.
+     * @see {@link HideStrategy}
+     */
+    hideStrategy?: HideStrategy;
+    /**
+     * Determines how the control's value is handled when visibility changes.
+     * @see {@link ValueStrategy}
+     */
+    valueStrategy?: ValueStrategy;
+    /**
+     * Indicates if the control is read-only (displayed but not modifiable).
+     * Accepts either a boolean value or a string expression for dynamic evaluation.
+     */
+    readonly?: Expression<boolean> | boolean;
+    /**
+     * Specifies when to update the control's value.
+     * @see {@link UpdateStrategy}
+     */
+    updateOn?: UpdateStrategy;
+    /**
+     * A value that is automatically derived and set for the control.
+     * It will overwrite user input if one of its dependencies changes.
+     */
+    computedValue?: Expression<unknown>;
+}
+/**
+ * Specifies when to update the control's value:
+ * - 'change': as user types (default)
+ * - 'blur': when control loses focus
+ * - 'submit': when form is submitted
+ */
+type UpdateStrategy = 'change' | 'blur' | 'submit' | undefined;
+/**
+ * Represents a group of controls that can be nested within a form.
+ */
+interface NgxFbFormGroup<T extends NgxFbBaseContent = NgxFbContent> extends NgxFbAbstractControl {
+    /**
+     * Specifies a title for the group
+     */
+    title?: string;
+    /**
+     * Dynamic title that can be evaluated from form data
+     */
+    dynamicTitle?: Expression<string>;
+    /**
+     * Object mapping keys to NgxFbContent that configure the controls of the group
+     */
+    controls: Record<string, T>;
+}
+/**
+ * Represents an individual form control with label and value properties.
+ */
+interface NgxFbControl extends NgxFbAbstractControl {
+    /**
+     * Specifies the label for the control
+     */
+    label?: string;
+    /**
+     * Dynamic label that can be evaluated from form data
+     */
+    dynamicLabel?: Expression<string>;
+    /**
+     * Default value for the control. Override this type in extending interfaces to match the control's value type.
+     */
+    defaultValue?: unknown;
+    /**
+     * Whether this control can have a null value. Used to set the same property through the reactive forms API.
+     */
+    nonNullable?: boolean;
+}
+/**
+ * Represents a block element that doesn't behave like a form control.
+ * Used for UI elements that aren't part of the form model.
+ */
+interface NgxFbBlock extends NgxFbBaseContent {
+    /**
+     * Required property for TypeScript to properly do type narrowing
+     */
+    isControl: false;
+    [key: string]: unknown;
+}
+/**
+ * Union type representing all possible content types that can be used in a form.
+ */
+type NgxFbContent = NgxFbFormGroup | NgxFbControl | NgxFbBlock;
+/**
+ * Specifies how to handle the control when hidden:
+ * - 'keep': control remains in form model
+ * - 'remove': control is removed from form model
+ */
+type HideStrategy = 'keep' | 'remove';
+/**
+ * Determines how the control's value is handled when visibility changes:
+ * - 'last': preserves last value
+ * - 'default': reverts to default value
+ * - 'reset': clears value
+ */
+type ValueStrategy = 'last' | 'default' | 'reset';
+
+interface NgxFbForm<ContentType extends NgxFbBaseContent = NgxFbContent> {
+    content: Record<string, ContentType>;
+}
+
+type SimpleFunction = () => void;
+type ValueHandleFunction = (valueStrategy?: ValueStrategy) => void;
+type TestIdBuilderFn = (content: NgxFbBaseContent, name: string, parentTestId?: string) => string;
+
+interface NgxFbGlobalConfiguration {
+    testIdBuilderFn: TestIdBuilderFn | undefined;
+}
+
+declare const NGX_FW_COMPONENT_REGISTRATIONS: InjectionToken<ReadonlyMap<string, ComponentRegistrationEntry>>;
+
+declare const NGX_FW_COMPONENT_RESOLVER: InjectionToken<ComponentResolver>;
+
+declare const NGX_FW_DEFAULT_CONFIG: InjectionToken<NgxFbGlobalConfiguration>;
+declare const NGX_FW_CONFIG: InjectionToken<readonly Partial<NgxFbGlobalConfiguration>[]>;
+declare const NGX_FW_CONFIG_RESOLVED: InjectionToken<NgxFbGlobalConfiguration>;
+
+declare const NGX_FW_DEFAULT_UPDATE_STRATEGY: InjectionToken<UpdateStrategy>;
+
+/**
+ * Service for parsing and evaluating JavaScript expressions within a context object
+ */
+declare class ExpressionService {
+    /**
+     * Cache for parsed ASTs to avoid re-parsing the same expression
+     */
+    private readonly astCache;
+    /**
+     * Parses an expression string into an abstract syntax tree (AST)
+     * @param expressionString - The expression to parse
+     * @returns The parsed AST or null
+     */
+    parseExpressionToAst(expressionString?: string): Program | null;
+    /**
+     * Evaluates an expression AST within the provided context
+     * @param ast - The parsed AST to evaluate
+     * @param context - The context containing variables and objects referenced in the expression
+     * @returns The result of evaluating the expression
+     */
+    evaluateExpression(ast?: Program | null, context?: FormContext): unknown;
+    /**
+     * Evaluates a node in the AST
+     * @param node - The AST node to evaluate
+     * @param context - The context containing variables and objects
+     * @returns The result of evaluating the node
+     */
+    private evaluateAstNode;
+    /**
+     * Evaluates a literal value node
+     * @param node - The literal node to evaluate
+     * @returns The literal value
+     */
+    private evaluateLiteral;
+    /**
+     * Evaluates a binary expression (e.g., a + b, x > y)
+     * @param node - The binary expression node
+     * @param context - The context containing variables and objects
+     * @returns The result of the binary operation
+     */
+    private evaluateBinaryExpression;
+    /**
+     * Executes a binary operation with the given values and operator
+     * @param leftValue - The left operand
+     * @param operator - The binary operator
+     * @param rightValue - The right operand
+     * @returns The result of applying the operator to the operands
+     */
+    private executeBinaryOperation;
+    /**
+     * Evaluates a member expression (e.g., obj.prop, arr[0]) with improved safety
+     * @param node - The member expression node
+     * @param context - The context containing variables and objects
+     * @returns The value of the member
+     */
+    private evaluateMemberExpression;
+    /**
+     * Gets a property from an object by key
+     * @param object - The object to retrieve the property from
+     * @param propertyKey - The property key (string or number)
+     * @returns The value of the property
+     */
+    private getPropertyFromObject;
+    /**
+     * Evaluates an identifier node by looking it up in the context
+     * @param node - The identifier node
+     * @param context - The context containing variables and objects
+     * @returns The value of the identifier from the context
+     */
+    private evaluateIdentifier;
+    /**
+     * Evaluates an array expression node
+     * @param node - The array expression node
+     * @param context - The context containing variables and objects
+     * @returns The evaluated array
+     */
+    private evaluateArrayExpression;
+    /**
+     * Evaluates a unary expression (e.g., !x, -value, typeof obj)
+     * @param node - The unary expression node
+     * @param context - The context containing variables and objects
+     * @returns The result of the unary operation
+     */
+    private evaluateUnaryExpression;
+    /**
+     * Evaluates a logical expression (&&, ||, ??)
+     * @param node - The logical expression node
+     * @param context - The context containing variables and objects
+     * @returns The result of the logical operation
+     */
+    private evaluateLogicalExpression;
+    /**
+     * Evaluates a conditional (ternary) expression (condition ? trueValue : falseValue)
+     * @param node - The conditional expression node
+     * @param context - The context containing variables and objects
+     * @returns The result based on the condition evaluation
+     */
+    private evaluateConditionalExpression;
+    /**
+     * Evaluates an object expression (object literal)
+     * @param node - The object expression node
+     * @param context - The context containing variables and objects
+     * @returns The evaluated object
+     */
+    private evaluateObjectExpression;
+    /**
+     * Evaluates a sequence expression (comma-separated expressions)
+     * @param node - The sequence expression node
+     * @param context - The context containing variables and objects
+     * @returns The result of the last expression in the sequence
+     */
+    private evaluateSequenceExpression;
+    /**
+     * Evaluates a template literal
+     * @param node - The template literal node
+     * @param context - The context containing variables and objects
+     * @returns The evaluated template string
+     */
+    private evaluateTemplateLiteral;
+    /**
+     * Evaluates a function call expression with strict type checking
+     * @param node - The function call expression node
+     * @param context - The context containing variables and objects
+     * @returns The result of the function call
+     */
+    private evaluateCallExpression;
+    /**
+     * Calls a method on an object after verifying it's safe to do so
+     * @param object - The object to call the method on
+     * @param methodName - The name of the method to call
+     * @param args - The arguments to pass to the method
+     * @returns The result of the method call
+     */
+    private callSafeMethod;
+    private isAllowedMethod;
+    /**
+     * Evaluates an arrow function expression
+     * @param node - The arrow function expression node
+     * @param context - The context containing variables and objects
+     * @returns A function that can be called from other expressions
+     */
+    private evaluateArrowFunctionExpression;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpressionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExpressionService>;
+}
+
+declare class ComponentRegistrationService implements ComponentResolver {
+    private readonly _registrations;
+    readonly registrations: i0.Signal<ReadonlyMap<string, _ngx_formbar_core.ComponentRegistrationEntry>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ComponentRegistrationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ComponentRegistrationService>;
+}
+
+declare class NgxFbConfigurationService {
+    private readonly _config;
+    get testIdBuilder(): TestIdBuilderFn | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgxFbConfigurationService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgxFbConfigurationService>;
+}
+
+/**
+ * Creates a static component registration entry.
+ * Use for eagerly imported components that don't need lazy loading.
+ *
+ * @example
+ * ```ts
+ * import { staticComponent } from '@ngx-formbar/core';
+ * import { TextComponent } from './text.component';
+ *
+ * const registrations = {
+ *   text: staticComponent(TextComponent),
+ * };
+ * ```
+ */
+declare function staticComponent(type: Type<unknown>): StaticRegistration;
+/**
+ * Creates a lazy component registration entry.
+ * Use for components that should be loaded on demand.
+ *
+ * @example
+ * ```ts
+ * import { loadComponent } from '@ngx-formbar/core';
+ *
+ * const registrations = {
+ *   text: loadComponent(() => import('./text.component').then(m => m.TextComponent)),
+ * };
+ * ```
+ */
+declare function loadComponent(load: LoadComponentFn): LazyRegistration;
+
+declare function toSafeString(value: unknown): string;
+
+/**
+ * Resolves an expression option into a computed signal value
+ *
+ * Handles three expression types:
+ * - **string**: Parsed to AST and evaluated against the form context
+ * - **function**: Called with the form context as argument
+ * - **static value / undefined**: Returned as-is
+ *
+ * Internally caches the parsed AST in a separate computed signal
+ * so it is only recalculated when the option itself changes.
+ *
+ * @param option Signal containing the expression option (string, function, static value, or undefined)
+ * @param formContext Signal providing the current form context for expression evaluation
+ * @param expressionService Service used to parse and evaluate string expressions
+ * @returns Computed signal that resolves to the evaluated value or undefined
+ */
+declare function resolveExpression<T>(option: Signal<Expression<T> | T | undefined>, formContext: Signal<FormContext>, expressionService: ExpressionService): Signal<T | undefined>;
+
+/**
+ * Resolves an inheritable boolean expression with parent state fallback
+ *
+ * Used for states like disabled and readonly that follow a common pattern:
+ * 1. If the option is undefined, inherit the parent state
+ * 2. Otherwise, resolve the expression and default to false
+ *
+ * @param option Signal containing the expression option (boolean, string expression, function, or undefined)
+ * @param formContext Signal providing the current form context for expression evaluation
+ * @param expressionService Service used to parse and evaluate string expressions
+ * @param parentState Signal providing the parent group's state to inherit from
+ * @returns Computed signal that resolves to a boolean state
+ */
+declare function resolveInheritableExpression(option: Signal<Expression<boolean> | boolean | undefined>, formContext: Signal<FormContext>, expressionService: ExpressionService, parentState: Signal<boolean>): Signal<boolean>;
+
+/**
+ * Resolves the hidden state with parent combination logic
+ *
+ * The hidden state differs from disabled/readonly inheritance:
+ * 1. If the option is undefined, inherit the parent hidden state
+ * 2. If the option is a function expression, use only the resolved value
+ * 3. If the option is a string expression, OR with the parent hidden state
+ *    (a child is hidden if either its own condition or its parent is hidden)
+ *
+ * @param option Signal containing the hidden expression option
+ * @param formContext Signal providing the current form context for expression evaluation
+ * @param expressionService Service used to parse and evaluate string expressions
+ * @param parentHiddenState Signal providing the parent group's hidden state
+ * @returns Computed signal that resolves to a boolean hidden state
+ */
+declare function resolveHiddenState(option: Signal<Expression<boolean> | boolean | undefined>, formContext: Signal<FormContext>, expressionService: ExpressionService, parentHiddenState: Signal<boolean>): Signal<boolean>;
+
+/**
+ * Creates an effect that manages disabled state transitions
+ *
+ * When disabledHandling is 'auto', calls the appropriate enable/disable
+ * function based on the disabled signal. When 'manual', does nothing.
+ *
+ * @param options Configuration object for disabled effect
+ * @param options.disabledSignal Signal that indicates if the component should be disabled
+ * @param options.disabledHandlingSignal Signal that determines how disabled state changes should be handled
+ * @param options.enableFunction Function to call when component should be enabled
+ * @param options.disableFunction Function to call when component should be disabled
+ */
+declare function resolveDisabledEffect(options: {
+    disabledSignal: Signal<boolean>;
+    disabledHandlingSignal: Signal<StateHandling>;
+    enableFunction: SimpleFunction;
+    disableFunction: SimpleFunction;
+}): void;
+
+/**
+ * Resolves a test ID for a form element
+ *
+ * The test ID is determined using the following priority:
+ * 1. A local testIdBuilder function if provided
+ * 2. A global testIdBuilder function if provided
+ * 3. Default: joins parentTestId and name with '-', or just name if no parent
+ *
+ * @param content Signal containing the base content configuration
+ * @param name Signal containing the control/group name
+ * @param testIdBuilder Signal holding an optional local testIdBuilder function
+ * @param globalTestIdBuilder Optional global testIdBuilder function from configuration
+ * @param parentTestId Signal providing the parent group's test ID
+ * @returns Computed signal that resolves to the test ID string
+ */
+declare function resolveTestId(content: Signal<NgxFbBaseContent>, name: Signal<string>, testIdBuilder: Signal<TestIdBuilderFn | undefined>, globalTestIdBuilder: TestIdBuilderFn | undefined, parentTestId: Signal<string | undefined>): Signal<string>;
+
+/**
+ * Resolves the hidden attribute value for DOM binding
+ *
+ * When visibilityHandling is 'auto', returns `true` (attribute present)
+ * or `null` (attribute absent) based on the hidden state.
+ * When visibilityHandling is 'manual', always returns `null` so the
+ * component can handle visibility itself.
+ *
+ * @param options Configuration object
+ * @param options.hiddenSignal Signal indicating whether the element should be hidden
+ * @param options.hiddenHandlingSignal Signal for the visibility handling strategy
+ * @returns Computed signal resolving to `true` (hidden) or `null` (visible)
+ */
+declare function resolveHiddenAttribute(options: {
+    hiddenSignal: Signal<boolean>;
+    hiddenHandlingSignal: Signal<StateHandling>;
+}): Signal<true | null>;
+
+/**
+ * Resolves the update strategy for a form control or group
+ *
+ * The strategy is determined using the following priority:
+ * 1. The control's own updateOn value if defined
+ * 2. The parent group's strategy if defined
+ * 3. The application-wide default strategy
+ *
+ * @param controlUpdateOn Signal containing the control's updateOn configuration
+ * @param parentStrategy Signal providing the parent group's update strategy
+ * @param defaultStrategy The application-wide default update strategy
+ * @returns Computed signal providing the resolved update strategy
+ */
+declare function resolveUpdateStrategy(controlUpdateOn: Signal<UpdateStrategy | undefined>, parentStrategy: Signal<UpdateStrategy | undefined>, defaultStrategy: UpdateStrategy): Signal<UpdateStrategy>;
+
+export { ComponentRegistrationService, ExpressionService, NGX_FW_COMPONENT_REGISTRATIONS, NGX_FW_COMPONENT_RESOLVER, NGX_FW_CONFIG, NGX_FW_CONFIG_RESOLVED, NGX_FW_DEFAULT_CONFIG, NGX_FW_DEFAULT_UPDATE_STRATEGY, NgxFbConfigurationService, loadComponent, resolveDisabledEffect, resolveExpression, resolveHiddenAttribute, resolveHiddenState, resolveInheritableExpression, resolveTestId, resolveUpdateStrategy, staticComponent, toSafeString };
+export type { ComponentRegistrationConfig, ComponentRegistrationEntry, ComponentResolver, Expression, FormContext, HideStrategy, LazyRegistration, LoadComponentFn, NgxFbAbstractControl, NgxFbBaseContent, NgxFbBlock, NgxFbContent, NgxFbControl, NgxFbForm, NgxFbFormGroup, NgxFbGlobalConfiguration, SimpleFunction, StateHandling, StaticRegistration, TestIdBuilderFn, UpdateStrategy, ValueHandleFunction, ValueStrategy };

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Alexander Pahn
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngx-formbar/core" />
-export * from './public-api';

package/lib/components/form/ngxfb-form.component.d.ts

@@ -1,28 +0,0 @@
-import { NgxFbBaseContent, NgxFbContent } from '../../types/content.type';
-import { NgxFbForm } from '../../types/form.type';
-import * as i0 from "@angular/core";
-/**
- * Ngx Formbar Form Component
- *
- * This component serves as the main container for Ngx Formbar forms:
- * - Takes a form configuration
- * - Establishes the form context through FormService provider
- * - Renders each content item using NgxfbAbstractControlDirective
- * - Handles component registration and dependency injection
- *
- * The component acts as the root element for declarative form creation,
- * processing the form content configuration and rendering the appropriate
- * components for each control defined in the configuration.
- */
-export declare class NgxfbFormComponent<T extends NgxFbBaseContent = NgxFbContent> {
-    /**
-     * Required input containing form configuration
-     */
-    readonly formConfig: import("@angular/core").InputSignal<NgxFbForm<T>>;
-    /**
-     * Computed value containing form content
-     */
-    readonly formContent: import("@angular/core").Signal<[string, T][]>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgxfbFormComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgxfbFormComponent<any>, "ngxfb-form", never, { "formConfig": { "alias": "formConfig"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}

package/lib/composables/computed-value.d.ts

@@ -1,8 +0,0 @@
-import { Signal } from '@angular/core';
-import { NgxFbAbstractControl } from '../types/content.type';
-import { AbstractControl } from '@angular/forms';
-export declare function withComputedValue<T>(content: Signal<NgxFbAbstractControl>): Signal<T | undefined>;
-export declare function setComputedValueEffect<T>(options: {
-    controlInstance: Signal<AbstractControl>;
-    computeValueSignal: Signal<T>;
-}): void;

package/lib/composables/disabled.state.d.ts

@@ -1,36 +0,0 @@
-import { Signal } from '@angular/core';
-import { StateHandling } from '../types/registration.type';
-import { SimpleFunction } from '../types/functions.type';
-import { NgxFbAbstractControl } from '../types/content.type';
-/**
- * Computes a reactive disabled state based on control content
- *
- * The disabled state is determined using the following priority:
- * 1. If content.disabled is a boolean, that value is used directly
- * 2. If content.disabled is an expression string, it's parsed to AST and evaluated
- *    against the current form values
- * 3. If no disabled property is defined, the control inherits the disabled state
- *    from its parent group
- *
- * This hierarchical inheritance ensures that child controls are automatically
- * disabled when their parent group is disabled, unless explicitly overridden.
- *
- * @param content Signal containing control configuration with potential disabled property
- * @returns Computed signal that resolves to boolean disabled state
- */
-export declare function withDisabledState(content: Signal<NgxFbAbstractControl>): Signal<boolean>;
-/**
- * Creates an effect that manages control/group disabled state
- *
- * @param options Configuration object for disabled effect
- * @param options.disabledSignal Signal that indicates if the component should be disabled
- * @param options.disabledHandlingSignal Signal that determines how disabled state changes should be handled
- * @param options.enableFunction Function to call when component should be enabled
- * @param options.disableFunction Function to call when component should be disabled
- */
-export declare function disabledEffect(options: {
-    disabledSignal: Signal<boolean>;
-    disabledHandlingSignal: Signal<StateHandling>;
-    enableFunction: SimpleFunction;
-    disableFunction: SimpleFunction;
-}): void;

package/lib/composables/dynamic-label.d.ts

@@ -1,9 +0,0 @@
-import { Signal } from '@angular/core';
-import { NgxFbControl } from '../types/content.type';
-/**
- * Computes a dynamic label for a form control based on expression evaluation
- *
- * @param content Signal containing control configuration with dynamicLabel property
- * @returns Computed signal that resolves to the evaluated dynamic label string or undefined
- */
-export declare function withDynamicLabel(content: Signal<NgxFbControl>): Signal<string | undefined>;

package/lib/composables/dynamic-title.d.ts

@@ -1,9 +0,0 @@
-import { Signal } from '@angular/core';
-import { NgxFbFormGroup } from '../types/content.type';
-/**
- * Computes a dynamic title for a form control based on expression evaluation
- *
- * @param content Signal containing control configuration with dynamicTitle property
- * @returns Computed signal that resolves to the evaluated dynamic title string or undefined
- */
-export declare function withDynamicTitle(content: Signal<NgxFbFormGroup>): Signal<string | undefined>;