@sapui5/sap.fe.core 1.100.0 → 1.102.0

package/src/sap/fe/core/helpers/ClassSupport.ts

@@ -1,15 +1,73 @@
-import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
+import merge from "sap/base/util/merge";
 import ObjectPath from "sap/base/util/ObjectPath";
-import ElementMetadata from "sap/ui/core/ElementMetadata";
-import RenderManager from "sap/ui/core/RenderManager";
-import Metadata from "sap/ui/base/Metadata";
-import ControllerExtensionMetadata from "sap/fe/core/controllerextensions/ControllerExtensionMetadata";
-import ControllerMetadata from "sap/ui/core/mvc/ControllerMetadata";
 import uid from "sap/base/util/uid";
-import merge from "sap/base/util/merge";
 import UI5Event from "sap/ui/base/Event";
+import Metadata from "sap/ui/base/Metadata";
+import ControllerExtension from "sap/ui/core/mvc/ControllerExtension";
+import ControllerMetadata from "sap/ui/core/mvc/ControllerMetadata";
+import OverrideExecution from "sap/ui/core/mvc/OverrideExecution";
 
-const ensureMetadata = function(target: any) {
+type OverrideDefinition = Record<string, Function>;
+type UI5ControllerMethodDefinition = {
+	overrideExecution?: OverrideExecution;
+	public?: boolean;
+	final?: boolean;
+};
+type UI5PropertyMetadata = {
+	type: string;
+	required?: boolean;
+	group?: string;
+	defaultValue?: any;
+};
+type UI5AggregationMetadata = {
+	type: string;
+	multiple?: boolean;
+	isDefault?: boolean;
+	singularName?: string;
+	visibility?: string;
+};
+type UI5AssociationMetadata = {
+	type: string;
+	multiple?: boolean;
+	singularName?: string;
+};
+type UI5ControlMetadataDefinition = {
+	defaultAggregation?: string;
+	controllerExtensions: Record<string, typeof ControllerExtension | Function>;
+	properties: Record<string, UI5PropertyMetadata>;
+	macroContexts: Record<string, UI5PropertyMetadata>;
+	aggregations: Record<string, UI5AggregationMetadata>;
+	associations: Record<string, UI5AssociationMetadata>;
+	methods: Record<string, UI5ControllerMethodDefinition>;
+	events: Record<string, {}>;
+	interfaces: string[];
+};
+type UI5Controller = {
+	override?: { extension?: Record<string, OverrideDefinition> } & {
+		[k: string]: Function;
+	};
+	metadata?: UI5ControlMetadataDefinition;
+};
+
+type UI5Control = {
+	metadata?: UI5ControlMetadataDefinition;
+};
+
+type UI5APIControl = UI5Control & {
+	getAPI(event: UI5Event): UI5APIControl;
+	[k: string]: Function;
+};
+
+type ControlPropertyNames<T> = {
+	[K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type PropertiesOf<T> = Partial<Pick<T, ControlPropertyNames<T>>>;
+export type StrictPropertiesOf<T> = Pick<T, ControlPropertyNames<T>>;
+export type EnhanceWithUI5<T> = T & {
+	// Add all the getXXX method, might add too much as i'm not filtering on actual properties actually...
+	[P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];
+};
+const ensureMetadata = function (target: UI5Controller) {
 	target.metadata = merge(
 		{
 			controllerExtensions: {},
@@ -18,205 +76,259 @@ const ensureMetadata = function(target: any) {
 			aggregations: {},
 			associations: {},
 			methods: {},
-			events: {}
+			events: {},
+			interfaces: []
 		},
 		target.metadata || {}
-	);
+	) as UI5ControlMetadataDefinition;
 	return target.metadata;
 };
-export function Override(sTarget?: string) {
-	return function(target: any, propertyKey: string) {
+
+/* #region CONTROLLER EXTENSIONS */
+
+/**
+ * Defines that the following method is an override for the method name with the same name in the specific controller extension or base implementation.
+ *
+ * @param extensionName The name of the extension that will be overriden
+ * @returns The decorated method
+ */
+export function methodOverride(extensionName?: string): MethodDecorator {
+	return function (target: UI5Controller, propertyKey) {
 		if (!target.override) {
 			target.override = {};
 		}
 		let currentTarget = target.override;
-		if (sTarget) {
+		if (extensionName) {
 			if (!currentTarget.extension) {
 				currentTarget.extension = {};
 			}
-			if (!currentTarget.extension[sTarget]) {
-				currentTarget.extension[sTarget] = {};
+			if (!currentTarget.extension[extensionName]) {
+				currentTarget.extension[extensionName] = {};
 			}
-			currentTarget = currentTarget.extension[sTarget];
+			currentTarget = currentTarget.extension[extensionName];
 		}
-		currentTarget[propertyKey] = target[propertyKey];
+		currentTarget[propertyKey.toString()] = (target as any)[propertyKey.toString()];
 	};
 }
-export function Extensible(oOverrideExecution?: OverrideExecution) {
-	return function(target: any, propertyKey: string) {
+
+/**
+ * Defines that the method can be extended by other controller extension based on the defined overrideExecutionType.
+ *
+ * @param overrideExecutionType The OverrideExecution defining when the override should run (Before / After / Instead)
+ * @returns The decorated method
+ */
+export function extensible(overrideExecutionType?: OverrideExecution): MethodDecorator {
+	return function (target: UI5Controller, propertyKey) {
 		const metadata = ensureMetadata(target);
-		if (!metadata.methods[propertyKey]) {
-			metadata.methods[propertyKey] = {};
+		if (!metadata.methods[propertyKey.toString()]) {
+			metadata.methods[propertyKey.toString()] = {};
 		}
-		metadata.methods[propertyKey].overrideExecution = oOverrideExecution;
+		metadata.methods[propertyKey.toString()].overrideExecution = overrideExecutionType;
 	};
 }
-export function Public(target: any, propertyKey: string, descriptor: any): any {
-	const metadata = ensureMetadata(target);
-	descriptor.enumerable = true;
-	if (!metadata.methods[propertyKey]) {
-		metadata.methods[propertyKey] = {};
-	}
-	metadata.methods[propertyKey].public = true;
-}
-export function Private(target: any, propertyKey: string, descriptor: any) {
-	const metadata = ensureMetadata(target);
-	descriptor.enumerable = true;
-	if (!metadata.methods[propertyKey]) {
-		metadata.methods[propertyKey] = {};
-	}
-	metadata.methods[propertyKey].public = false;
-}
-export function Final(target: any, propertyKey: string, descriptor: any) {
-	const metadata = ensureMetadata(target);
-	descriptor.enumerable = true;
-	if (!metadata.methods[propertyKey]) {
-		metadata.methods[propertyKey] = {};
-	}
-	metadata.methods[propertyKey].final = true;
-}
 
-export function Event(target: any, eventKey: string) {
-	const metadata = ensureMetadata(target);
-	if (!metadata.events[eventKey]) {
-		metadata.events[eventKey] = {};
-	}
+/**
+ * Defines that the method will be publicly available for controller extension usage.
+ *
+ * @returns The decorated method
+ */
+export function publicExtension(): MethodDecorator {
+	return function (target: UI5Controller, propertyKey, descriptor): void {
+		const metadata = ensureMetadata(target);
+		descriptor.enumerable = true;
+		if (!metadata.methods[propertyKey.toString()]) {
+			metadata.methods[propertyKey.toString()] = {};
+		}
+		metadata.methods[propertyKey.toString()].public = true;
+	};
 }
-
-export function EventHandler(target: any, propertykey: any) {
-	target.constructor[propertykey] = function(...args: any[]) {
-		const currentTarget = target.constructor.getAPI(args[0] as UI5Event);
-		currentTarget[propertykey](...args);
+/**
+ * Defines that the method will be only available for internal usage of the controller extension.
+ *
+ * @returns The decorated method
+ */
+export function privateExtension(): MethodDecorator {
+	return function (target: UI5Controller, propertyKey, descriptor) {
+		const metadata = ensureMetadata(target);
+		descriptor.enumerable = true;
+		if (!metadata.methods[propertyKey.toString()]) {
+			metadata.methods[propertyKey.toString()] = {};
+		}
+		metadata.methods[propertyKey.toString()].public = false;
 	};
 }
-
-export function MacroContext(bMetaModelObject: boolean = false): any {
-	return Property({ type: "sap.ui.model.Context", macroContext: true, metaModelObject: bMetaModelObject });
+/**
+ * Defines that the method cannot be further extended by other controller extension.
+ *
+ * @returns The decorated method
+ */
+export function finalExtension(): MethodDecorator {
+	return function (target: UI5Controller, propertyKey, descriptor) {
+		const metadata = ensureMetadata(target);
+		descriptor.enumerable = true;
+		if (!metadata.methods[propertyKey.toString()]) {
+			metadata.methods[propertyKey.toString()] = {};
+		}
+		metadata.methods[propertyKey.toString()].final = true;
+	};
 }
 
-export function UsingExtension(extensionClass: any): any {
-	return function(target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor): any {
+/**
+ * Defines that we are going to use instantiate a controller extension under the following variable name.
+ *
+ * @param extensionClass The controller extension that will be instantiated
+ * @returns The decorated property
+ */
+export function usingExtension(extensionClass: typeof ControllerExtension | Function): PropertyDecorator {
+	return function (target: UI5Controller, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {
 		const metadata = ensureMetadata(target);
 		delete (propertyDescriptor as any).initializer;
-		metadata.controllerExtensions[propertyKey] = extensionClass;
+		metadata.controllerExtensions[propertyKey.toString()] = extensionClass;
 		return propertyDescriptor;
-	};
+	} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.
 }
-export function Property(oPropertyParams: any): any {
-	return function(target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor): any {
+
+/* #endregion */
+
+/* #region CONTROL */
+/**
+ * Indicates that the property shall be declared as an event on the control metadata.
+ *
+ * @returns The decorated property
+ */
+export function event(): PropertyDecorator {
+	return function (target: UI5Control, eventKey) {
 		const metadata = ensureMetadata(target);
-		if (oPropertyParams?.macroContext) {
-			if (!metadata.macroContexts[propertyKey]) {
-				metadata.macroContexts[propertyKey] = oPropertyParams;
-			}
+		if (!metadata.events[eventKey.toString()]) {
+			metadata.events[eventKey.toString()] = {};
 		}
+	};
+}
+
+/**
+ * Defines the following property in the control metatada.
+ *
+ * @param ui5PropertyMetadata The property definition
+ * @returns The decorated property.
+ */
+export function property(ui5PropertyMetadata: UI5PropertyMetadata): PropertyDecorator {
+	return function (target: UI5Control, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {
+		const metadata = ensureMetadata(target);
 		if (!metadata.properties[propertyKey]) {
-			metadata.properties[propertyKey] = oPropertyParams;
+			metadata.properties[propertyKey] = ui5PropertyMetadata;
 		}
 		delete propertyDescriptor.writable;
 		delete (propertyDescriptor as any).initializer;
-		// (propertyDescriptor as any).set = function(v: any) {
-		// 	return this.setProperty(propertyKey, v);
-		// };
-		// (propertyDescriptor as any).get = function() {
-		// 	return this.getProperty(propertyKey);
-		// };
 
 		return propertyDescriptor;
-	};
+	} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
 }
-
-export function Aggregation(oAggregationDescriptor?: any): any {
-	return function(target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor): any {
+/**
+ * Defines and configure the following aggregation in the control metatada.
+ *
+ * @param ui5AggregationMetadata The aggregation definition
+ * @returns The decorated property.
+ */
+export function aggregation(ui5AggregationMetadata: UI5AggregationMetadata): PropertyDecorator {
+	return function (target: UI5Control, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {
 		const metadata = ensureMetadata(target);
+		if (ui5AggregationMetadata.multiple === undefined) {
+			// UI5 defaults this to true but this is just weird...
+			ui5AggregationMetadata.multiple = false;
+		}
 		if (!metadata.aggregations[propertyKey]) {
-			metadata.aggregations[propertyKey] = oAggregationDescriptor;
+			metadata.aggregations[propertyKey] = ui5AggregationMetadata;
 		}
-		if (oAggregationDescriptor.isDefault) {
+		if (ui5AggregationMetadata.isDefault) {
 			metadata.defaultAggregation = propertyKey;
 		}
 		delete propertyDescriptor.writable;
 		delete (propertyDescriptor as any).initializer;
-		// (propertyDescriptor as any).set = function(v: any) {
-		// 	return this.setAggregation(propertyKey, v);
-		// };
-		// (propertyDescriptor as any).get = function() {
-		// 	return this.getAggregation(propertyKey);
-		// };
 
 		return propertyDescriptor;
-	};
+	} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
 }
 
-export function Association(oAssociationDescription?: any): any {
-	return function(target: any, propertyKey: string, propertyDescriptor: PropertyDescriptor): any {
+/**
+ * Defines and configure the following association in the control metatada.
+ *
+ * @param ui5AssociationMetadata The definition of the association.
+ * @returns The decorated property
+ */
+export function association(ui5AssociationMetadata: UI5AssociationMetadata): PropertyDecorator {
+	return function (target: UI5Control, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {
 		const metadata = ensureMetadata(target);
 		if (!metadata.associations[propertyKey]) {
-			metadata.associations[propertyKey] = oAssociationDescription;
+			metadata.associations[propertyKey] = ui5AssociationMetadata;
 		}
 		delete propertyDescriptor.writable;
 		delete (propertyDescriptor as any).initializer;
-		// (propertyDescriptor as any).set = function(v: any) {
-		// 	return this.setAggregation(propertyKey, v);
-		// };
-		// (propertyDescriptor as any).get = function() {
-		// 	return this.getAggregation(propertyKey);
-		// };
 
 		return propertyDescriptor;
-	};
+	} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
 }
-type ControlPropertyNames<T> = {
-	[K in keyof T]: T[K] extends Function ? never : K;
-}[keyof T];
-export type PropertiesOf<T> = Partial<Pick<T, ControlPropertyNames<T>>>;
 
 /**
- * Decorator to provide a new API class to be used in the macros.
+ * Defines in the metadata that this control implements a specific interface.
  *
- * @param sTarget The fully qualified name of the macro API
- * @param isDependentBound Whether this API will be used as a dependent or not
- * @class
+ * @param interfaceName The name of the implemented interface
+ * @returns The decorated method
  */
-export function APIClass(sTarget: string, isDependentBound = false) {
-	return function(constructor: Function) {
-		if (!constructor.prototype.metadata) {
-			constructor.prototype.metadata = {};
-		}
+export function implementInterface(interfaceName: string): PropertyDecorator {
+	return function (target: UI5Control) {
+		const metadata = ensureMetadata(target);
 
-		if (!constructor.prototype.metadata.interfaces) {
-			constructor.prototype.metadata.interfaces = [];
-		}
-		constructor.prototype.metadata.interfaces.push("sap.ui.core.IFormContent");
-		(constructor as any).isDependentBound = isDependentBound;
-		if (!constructor.prototype.renderer) {
-			constructor.prototype.renderer = {
-				apiVersion: 2,
-				render: function(oRm: RenderManager, oControl: any) {
-					oRm.renderControl(oControl.getContent());
-				}
-			};
-		}
+		metadata.interfaces.push(interfaceName);
+	};
+}
 
-		describe(constructor, sTarget, constructor.prototype, ElementMetadata);
+/**
+ * Indicates that the following method should also be exposed statically so we can call it from the XML.
+ *
+ * @returns The decorated method
+ */
+export function xmlEventHandler(): MethodDecorator {
+	return function (target: UI5Control, propertykey) {
+		const currentConstructor: UI5APIControl = target.constructor as unknown as UI5APIControl;
+		currentConstructor[propertykey.toString()] = function (...args: any[]) {
+			const currentTarget = currentConstructor.getAPI(args[0] as UI5Event);
+			currentTarget[propertykey.toString()](...args);
+		};
 	};
 }
-export function UI5Class(sTarget: string, metadataClass?: any, metadataDefinition?: any, useExtend: boolean = true) {
-	return function(constructor: Function) {
+
+/**
+ * Indicates that the following class should define a ui5 control of the specified name.
+ *
+ * @param sTarget The fully qualified name of the macro API
+ * @param metadataDefinition Inline metadata definition
+ * @class
+ */
+export function defineUI5Class(sTarget: string, metadataDefinition?: any): ClassDecorator {
+	return function (constructor: Function) {
 		if (!constructor.prototype.metadata) {
 			constructor.prototype.metadata = {};
 		}
 		if (metadataDefinition) {
-			Object.keys(metadataDefinition).forEach(key => {
-				constructor.prototype.metadata[key] = metadataDefinition[key];
-			});
+			for (const key in metadataDefinition) {
+				constructor.prototype.metadata[key] = metadataDefinition[key as keyof UI5ControlMetadataDefinition];
+			}
 		}
-		return describe(constructor, sTarget, constructor.prototype, metadataClass, useExtend);
+		return registerUI5Metadata(constructor, sTarget, constructor.prototype);
 	};
 }
-function describe(clazz: any, name: string, inObj: any, metadataClass?: any, useExtend: boolean = true) {
-	if (metadataClass === ControllerExtensionMetadata) {
-		Object.getOwnPropertyNames(inObj).forEach(objName => {
+
+/**
+ * Internal heavy lifting that will take care of creating the class property for ui5 to use.
+ *
+ * @param clazz The class prototype
+ * @param name The name of the class to create
+ * @param inObj The metadata object
+ * @returns The metadata class
+ */
+function registerUI5Metadata(clazz: any, name: string, inObj: any): any {
+	if (clazz.getMetadata && clazz.getMetadata().isA("sap.ui.core.mvc.ControllerExtension")) {
+		Object.getOwnPropertyNames(inObj).forEach((objName) => {
 			const descriptor = Object.getOwnPropertyDescriptor(inObj, objName);
 			if (descriptor && !descriptor.enumerable) {
 				descriptor.enumerable = true;
@@ -228,104 +340,90 @@ function describe(clazz: any, name: string, inObj: any, metadataClass?: any, use
 	obj.metadata = inObj.metadata || {};
 	obj.override = inObj.override;
 	obj.constructor = clazz;
-	obj.metadata.baseType = Object.getPrototypeOf(clazz.prototype)
-		.getMetadata()
-		.getName();
+	obj.metadata.baseType = Object.getPrototypeOf(clazz.prototype).getMetadata().getName();
 
-	const rendererDefinition = inObj.renderer || clazz.renderer;
-	obj.renderer = { apiVersion: 2 };
-	if (typeof rendererDefinition === "function") {
-		obj.renderer.render = rendererDefinition;
-	} else if (rendererDefinition != undefined) {
-		obj.renderer = rendererDefinition;
+	if (clazz?.getMetadata()?.getStereotype() === "control") {
+		const rendererDefinition = inObj.renderer || clazz.renderer || clazz.render;
+		obj.renderer = { apiVersion: 2 };
+		if (typeof rendererDefinition === "function") {
+			obj.renderer.render = rendererDefinition;
+		} else if (rendererDefinition != undefined) {
+			obj.renderer = rendererDefinition;
+		}
 	}
 	obj.metadata.interfaces = inObj.metadata?.interfaces || clazz.metadata?.interfaces;
-	if (useExtend) {
-		Object.keys(clazz.prototype).forEach(key => {
-			if (key !== "metadata") {
-				try {
-					obj[key] = clazz.prototype[key];
-				} catch (e) {
-					//console.log(e);
-				}
+	Object.keys(clazz.prototype).forEach((key) => {
+		if (key !== "metadata") {
+			try {
+				obj[key] = clazz.prototype[key];
+			} catch (e) {
+				//console.log(e);
 			}
-		});
-	}
+		}
+	});
 	if (obj.metadata?.controllerExtensions && Object.keys(obj.metadata.controllerExtensions).length > 0) {
 		for (const cExtName in obj.metadata.controllerExtensions) {
 			obj[cExtName] = obj.metadata.controllerExtensions[cExtName];
 		}
 	}
-	let output = clazz;
-	if (useExtend) {
-		output = clazz.extend(name, obj, metadataClass);
-		const fnInit = output.prototype.init;
-		output.prototype.init = function(...args: any[]) {
-			fnInit && fnInit.apply(this, args);
-			this.metadata = obj.metadata;
+	const output = clazz.extend(name, obj);
+	const fnInit = output.prototype.init;
+	output.prototype.init = function (...args: any[]) {
+		fnInit && fnInit.apply(this, args);
+		this.metadata = obj.metadata;
 
-			if (obj.metadata.properties) {
-				const aPropertyKeys = Object.keys(obj.metadata.properties);
-				// eslint-disable-next-line @typescript-eslint/no-this-alias
-				const that = this;
-				aPropertyKeys.forEach(propertyKey => {
-					Object.defineProperty(that, propertyKey, {
-						configurable: true,
-						set: (v: any) => {
-							return that.setProperty(propertyKey, v);
-						},
-						get: () => {
-							return that.getProperty(propertyKey);
+		if (obj.metadata.properties) {
+			const aPropertyKeys = Object.keys(obj.metadata.properties);
+			aPropertyKeys.forEach((propertyKey) => {
+				Object.defineProperty(this, propertyKey, {
+					configurable: true,
+					set: (v: any) => {
+						return this.setProperty(propertyKey, v);
+					},
+					get: () => {
+						return this.getProperty(propertyKey);
+					}
+				});
+			});
+			const aAggregationKeys = Object.keys(obj.metadata.aggregations);
+			aAggregationKeys.forEach((aggregationKey) => {
+				Object.defineProperty(this, aggregationKey, {
+					configurable: true,
+					set: (v: any) => {
+						return this.setAggregation(aggregationKey, v);
+					},
+					get: () => {
+						const aggregationContent = this.getAggregation(aggregationKey);
+						if (obj.metadata.aggregations[aggregationKey].multiple) {
+							return aggregationContent || [];
+						} else {
+							return aggregationContent;
 						}
-					});
+					}
 				});
-				const aAggregationKeys = Object.keys(obj.metadata.aggregations);
-				aAggregationKeys.forEach(aggregationKey => {
-					Object.defineProperty(that, aggregationKey, {
-						configurable: true,
-						set: (v: any) => {
-							return that.setAggregation(aggregationKey, v);
-						},
-						get: () => {
-							return that.getAggregation(aggregationKey);
+			});
+			const aAssociationKeys = Object.keys(obj.metadata.associations);
+			aAssociationKeys.forEach((associationKey) => {
+				Object.defineProperty(this, associationKey, {
+					configurable: true,
+					set: (v: any) => {
+						return this.setAssociation(associationKey, v);
+					},
+					get: () => {
+						const aggregationContent = this.getAssociation(associationKey);
+						if (obj.metadata.associations[associationKey].multiple) {
+							return aggregationContent || [];
+						} else {
+							return aggregationContent;
 						}
-					});
+					}
 				});
-			}
-		};
-	} else {
-		let metadata: any;
-		if (metadataClass) {
-			metadata = new metadataClass(name, obj);
-		} else {
-			metadata = new ElementMetadata(name, obj);
-		}
-		clazz.getMetadata = clazz.prototype.getMetadata = function() {
-			return metadata;
-		};
-		if (!clazz.getMetadata().isFinal()) {
-			clazz.extend = function(sSCName: string, oSCClassInfo: any, fnSCMetaImpl: Function) {
-				// the default constructor created by ui5 does not return the value which is problematic with TS
-				oSCClassInfo.constructor = function(...args: any[]) {
-					return clazz.apply(this, args);
-				};
-
-				const fnClass = (Metadata as any).createClass(
-					clazz,
-					sSCName,
-					oSCClassInfo,
-					fnSCMetaImpl || metadataClass || ElementMetadata
-				);
-				// fnClass.prototype.constructor = function(...args: any[]) {
-				// 	return clazz.apply(this, ...args);
-				// };
-				return fnClass;
-			};
+			});
 		}
-	}
-	clazz.override = function(oExtension: any) {
+	};
+	clazz.override = function (oExtension: any) {
 		const pol = {};
-		(pol as any).constructor = function(...args: any[]) {
+		(pol as any).constructor = function (...args: any[]) {
 			return clazz.apply(this, args as any);
 		};
 		const oClass = (Metadata as any).createClass(clazz, "anonymousExtension~" + uid(), pol, ControllerMetadata);
@@ -334,26 +432,6 @@ function describe(clazz: any, name: string, inObj: any, metadataClass?: any, use
 		return oClass;
 	};
 
-	const fnInit = clazz.prototype.init;
-	output.prototype.init = function(...args: any[]) {
-		fnInit && fnInit.apply(this, args);
-		if (obj.metadata.properties) {
-			const aPropertyKeys = Object.keys(obj.metadata.properties);
-			// eslint-disable-next-line @typescript-eslint/no-this-alias
-			const that = this;
-			aPropertyKeys.forEach(propertyKey => {
-				Object.defineProperty(that, propertyKey, {
-					configurable: true,
-					set: (v: any) => {
-						return that.setProperty(propertyKey, v);
-					},
-					get: () => {
-						return that.getProperty(propertyKey);
-					}
-				});
-			});
-		}
-	};
 	ObjectPath.set(name, output);
 	return output;
 }