What kind of change does this PR introduce? - Bug fix

Background:

While using advanced JavaScript compilers such as:

• Google Closure Compiler (Advanced Mode)
• Terser (with property mangling enabled)
• Babel Minify (with minify-mangle-names)
• UglifyJS (with mangle-props option)


The current implementation of the library encounters issues due to direct property access obj.key being transformed during the compilation process. This results in runtime errors because object keys get minified or renamed by the compiler.

Problem Statement:

In most cases, the current approach works well when defining interfaces in TypeScript. Consider the following example:

interface SomeInterface {
  someProperty: string;
}

Advanced JavaScript compilers like Google Closure Compiler or Terser analyze all usages of this interface and minify keys consistently across all instances:

interface SomeInterface {
  someProperty: string;
} 
// After compilation:
interface SomeInterface {
  dO: string; // Minified key
}

However, there are certain edge cases where this behavior causes runtime errors.

Root Cause:

The issue occurs when properties are minified but accessed later using a string literal key:

const foo: SomeInterface = { someProperty: 'prop' };

// After compilation:
console.log(foo);                  // Outputs: { dO: 'prop' }
console.log(foo['someProperty']);  // Outputs: undefined (key is minified)

Since the compiler renames someProperty to dO, any access using the original key foo['someProperty'] will fail because the key no longer exists after minification.

A good example of when defineHiddenProp or hasOwnProperty are used:

export function defineHiddenProp(field: any, prop: string, defaultValue: any) {
  Object.defineProperty(field, prop, { enumerable: false, writable: true, configurable: true });
  field[prop] = defaultValue;
}

if (field.hasOwnProperty('fieldGroup') && !hasKey(field)) {
  defineHiddenProp(field, 'formControl', field.form);
} 

Proposed Solution:

To prevent this, TypeScript’s declare keyword should be used when defining interfaces:

declare interface SomeInterface {
  someProperty: string;
}

Using declare instructs the compiler not to minify properties in this interface, ensuring compatibility with advanced compilers. This change prevents key renaming and resolves potential runtime issues caused by minification.

Please check if the PR fulfills these requirements

• The commit messages follow our guidelines: https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#commit-message-format
• A unit test has been written for this change.
• Running npm run build produced a successful build. (Unit testing can be done by running npm test;)
• My code has been linted. (npm run lint to do this. npm run build will fail if there are files not linted.)

By applying this fix, ngx-formly will be more robust, supporting both standard and minified builds without risking property-access issues. Let me know if you need further clarification!