Configuration & Module Setup

/**
 * Main NgModule for integrating Formly into Angular applications
 */
@NgModule()
export class FormlyModule {
  /**
   * Configure Formly for the root module with global configuration
   * @param config - Optional configuration options for field types, validators, etc.
   * @returns Module with providers configured for root
   */
  static forRoot(config?: ConfigOption): ModuleWithProviders<FormlyModule>;
  
  /**
   * Configure Formly for feature modules with additional configuration
   * @param config - Optional configuration options for field types, validators, etc.
   * @returns Module with providers configured for child modules
   */
  static forChild(config?: ConfigOption): ModuleWithProviders<FormlyModule>;
}

import { NgModule } from '@angular/core';
import { ReactiveFormsModule } from '@angular/forms';
import { FormlyModule } from '@ngx-formly/core';

@NgModule({
  imports: [
    ReactiveFormsModule,
    FormlyModule.forRoot({
      types: [
        { name: 'input', component: FormlyFieldInput },
        { name: 'textarea', component: FormlyFieldTextarea },
      ],
      validators: [
        { name: 'email', validation: emailValidator },
      ],
    }),
  ],
})
export class AppModule {}

/**
 * Provides Formly core functionality for standalone components
 * @param configs - Configuration options or array of configuration options
 * @returns Provider array for dependency injection
 */
function provideFormlyCore(configs?: ConfigOption | ConfigOption[]): Provider;

/**
 * Provides additional Formly configuration for standalone components
 * @param configs - Configuration options or array of configuration options
 * @returns Provider array for dependency injection
 */
function provideFormlyConfig(configs?: ConfigOption | ConfigOption[]): Provider;

import { bootstrapApplication } from '@angular/platform-browser';
import { provideFormlyCore } from '@ngx-formly/core';
import { AppComponent } from './app/app.component';

bootstrapApplication(AppComponent, {
  providers: [
    provideFormlyCore({
      types: [
        { name: 'input', component: FormlyFieldInput },
      ],
      validators: [
        { name: 'required', validation: Validators.required },
      ],
    }),
  ],
});

/**
 * Creates configuration option with default Formly configuration
 * @param config - FormlyConfig instance with default settings
 * @returns ConfigOption for use with forRoot/forChild or providers
 */
function withDefaultConfig(config: FormlyConfig): ConfigOption;

/**
 * Injection token for registering additional Formly configuration options
 * Used internally by the configuration system
 */
const FORMLY_CONFIG: InjectionToken<ConfigOption[]>;

import { InjectionToken } from '@angular/core';
import { FORMLY_CONFIG } from '@ngx-formly/core';

const customConfig: ConfigOption = {
  types: [
    { name: 'custom-input', component: CustomInputComponent },
  ],
};

@NgModule({
  providers: [
    { provide: FORMLY_CONFIG, useValue: customConfig, multi: true },
  ],
})
export class FeatureModule {}

interface ConfigOption {
  /** Field type configurations */
  types?: FieldTypeConfig[];
  /** Wrapper configurations */
  wrappers?: WrapperOption[];
  /** Validator configurations */
  validators?: ValidatorOption[];
  /** Extension configurations */
  extensions?: FormlyExtension[];
  /** Validation message configurations */
  validationMessages?: ValidationMessageOption[];
  /** Extra configuration options */
  extras?: FormlyConfig['extras'];
  /** Preset configurations */
  presets?: PresetOption[];
}

interface FieldTypeConfig {
  /** Unique name for the field type */
  name: string;
  /** Component class for rendering the field */
  component?: Type<FieldType>;
  /** Default wrappers to apply */
  wrappers?: string[];
  /** Default properties */
  defaultOptions?: FormlyFieldConfig;
  /** Extends an existing field type */
  extends?: string;
}

interface WrapperOption {
  /** Unique name for the wrapper */
  name: string;
  /** Component class for the wrapper */
  component: Type<FieldWrapper>;
  /** Field types this wrapper applies to */
  types?: string[];
}

interface ValidatorOption {
  /** Unique name for the validator */
  name: string;
  /** Validator function (sync or async) */
  validation: ValidatorFn | AsyncValidatorFn;
  /** Additional options for the validator */
  options?: { [id: string]: any };
}

interface ValidationMessageOption {
  /** Validator name this message applies to */
  name: string;
  /** Message string or function returning message */
  message: string | ((error: any, field: FormlyFieldConfig) => string);
}

interface PresetOption {
  /** Unique name for the preset */
  name: string;
  /** Configuration to apply when preset is used */
  config: FormlyFieldConfig;
}

interface FormlyExtension {
  /** Unique name for the extension */
  name?: string;
  /** Priority for extension execution order */
  priority?: number;
  /** Called before field creation */
  prePopulate?: (field: FormlyFieldConfig) => void;
  /** Called after field creation */
  onPopulate?: (field: FormlyFieldConfig) => void;
  /** Called after form creation */
  postPopulate?: (field: FormlyFieldConfig) => void;
}