@sapui5/sap.fe.core 1.110.0 → 1.111.0

package/src/sap/fe/core/helpers/ClassSupport-dbg.js

@@ -0,0 +1,421 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2023 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/base/util/merge", "sap/base/util/ObjectPath", "sap/base/util/uid", "sap/ui/base/Metadata", "sap/ui/core/mvc/ControllerMetadata"], function (merge, ObjectPath, uid, Metadata, ControllerMetadata) {
+  "use strict";
+
+  var _exports = {};
+  const ensureMetadata = function (target) {
+    target.metadata = merge({
+      controllerExtensions: {},
+      properties: {},
+      aggregations: {},
+      associations: {},
+      methods: {},
+      events: {},
+      interfaces: []
+    }, target.metadata || {});
+    return target.metadata;
+  };
+
+  /* #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 overridden
+   * @returns The decorated method
+   */
+  function methodOverride(extensionName) {
+    return function (target, propertyKey) {
+      if (!target.override) {
+        target.override = {};
+      }
+      let currentTarget = target.override;
+      if (extensionName) {
+        if (!currentTarget.extension) {
+          currentTarget.extension = {};
+        }
+        if (!currentTarget.extension[extensionName]) {
+          currentTarget.extension[extensionName] = {};
+        }
+        currentTarget = currentTarget.extension[extensionName];
+      }
+      currentTarget[propertyKey.toString()] = target[propertyKey.toString()];
+    };
+  }
+
+  /**
+   * 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
+   */
+  _exports.methodOverride = methodOverride;
+  function extensible(overrideExecutionType) {
+    return function (target, propertyKey) {
+      const metadata = ensureMetadata(target);
+      if (!metadata.methods[propertyKey.toString()]) {
+        metadata.methods[propertyKey.toString()] = {};
+      }
+      metadata.methods[propertyKey.toString()].overrideExecution = overrideExecutionType;
+    };
+  }
+
+  /**
+   * Defines that the method will be publicly available for controller extension usage.
+   *
+   * @returns The decorated method
+   */
+  _exports.extensible = extensible;
+  function publicExtension() {
+    return function (target, propertyKey, descriptor) {
+      const metadata = ensureMetadata(target);
+      descriptor.enumerable = true;
+      if (!metadata.methods[propertyKey.toString()]) {
+        metadata.methods[propertyKey.toString()] = {};
+      }
+      metadata.methods[propertyKey.toString()].public = true;
+    };
+  }
+  /**
+   * Defines that the method will be only available for internal usage of the controller extension.
+   *
+   * @returns The decorated method
+   */
+  _exports.publicExtension = publicExtension;
+  function privateExtension() {
+    return function (target, propertyKey, descriptor) {
+      const metadata = ensureMetadata(target);
+      descriptor.enumerable = true;
+      if (!metadata.methods[propertyKey.toString()]) {
+        metadata.methods[propertyKey.toString()] = {};
+      }
+      metadata.methods[propertyKey.toString()].public = false;
+    };
+  }
+  /**
+   * Defines that the method cannot be further extended by other controller extension.
+   *
+   * @returns The decorated method
+   */
+  _exports.privateExtension = privateExtension;
+  function finalExtension() {
+    return function (target, propertyKey, descriptor) {
+      const metadata = ensureMetadata(target);
+      descriptor.enumerable = true;
+      if (!metadata.methods[propertyKey.toString()]) {
+        metadata.methods[propertyKey.toString()] = {};
+      }
+      metadata.methods[propertyKey.toString()].final = true;
+    };
+  }
+
+  /**
+   * 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
+   */
+  _exports.finalExtension = finalExtension;
+  function usingExtension(extensionClass) {
+    return function (target, propertyKey, propertyDescriptor) {
+      const metadata = ensureMetadata(target);
+      delete propertyDescriptor.initializer;
+      metadata.controllerExtensions[propertyKey.toString()] = extensionClass;
+      return propertyDescriptor;
+    }; // This is technically an accessor decorator, but somehow the compiler doesn't like it if I declare it as such.
+  }
+
+  /* #endregion */
+
+  /* #region CONTROL */
+  /**
+   * Indicates that the property shall be declared as an event on the control metadata.
+   *
+   * @returns The decorated property
+   */
+  _exports.usingExtension = usingExtension;
+  function event() {
+    return function (target, eventKey) {
+      const metadata = ensureMetadata(target);
+      if (!metadata.events[eventKey.toString()]) {
+        metadata.events[eventKey.toString()] = {};
+      }
+    };
+  }
+
+  /**
+   * Defines the following property in the control metatada.
+   *
+   * @param attributeDefinition The property definition
+   * @returns The decorated property.
+   */
+  _exports.event = event;
+  function property(attributeDefinition) {
+    return function (target, propertyKey, propertyDescriptor) {
+      const metadata = ensureMetadata(target);
+      if (!metadata.properties[propertyKey]) {
+        metadata.properties[propertyKey] = attributeDefinition;
+      }
+      delete propertyDescriptor.writable;
+      delete propertyDescriptor.initializer;
+      return propertyDescriptor;
+    }; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
+  }
+  /**
+   * Defines and configure the following aggregation in the control metatada.
+   *
+   * @param aggregationDefinition The aggregation definition
+   * @returns The decorated property.
+   */
+  _exports.property = property;
+  function aggregation(aggregationDefinition) {
+    return function (target, propertyKey, propertyDescriptor) {
+      const metadata = ensureMetadata(target);
+      if (aggregationDefinition.multiple === undefined) {
+        // UI5 defaults this to true but this is just weird...
+        aggregationDefinition.multiple = false;
+      }
+      if (!metadata.aggregations[propertyKey]) {
+        metadata.aggregations[propertyKey] = aggregationDefinition;
+      }
+      if (aggregationDefinition.isDefault) {
+        metadata.defaultAggregation = propertyKey;
+      }
+      delete propertyDescriptor.writable;
+      delete propertyDescriptor.initializer;
+      return propertyDescriptor;
+    }; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
+  }
+
+  /**
+   * Defines and configure the following association in the control metatada.
+   *
+   * @param ui5AssociationMetadata The definition of the association.
+   * @returns The decorated property
+   */
+  _exports.aggregation = aggregation;
+  function association(ui5AssociationMetadata) {
+    return function (target, propertyKey, propertyDescriptor) {
+      const metadata = ensureMetadata(target);
+      if (!metadata.associations[propertyKey]) {
+        metadata.associations[propertyKey] = ui5AssociationMetadata;
+      }
+      delete propertyDescriptor.writable;
+      delete propertyDescriptor.initializer;
+      return propertyDescriptor;
+    }; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
+  }
+
+  /**
+   * Defines in the metadata that this control implements a specific interface.
+   *
+   * @param interfaceName The name of the implemented interface
+   * @returns The decorated method
+   */
+  _exports.association = association;
+  function implementInterface(interfaceName) {
+    return function (target) {
+      const metadata = ensureMetadata(target);
+      metadata.interfaces.push(interfaceName);
+    };
+  }
+
+  /**
+   * Indicates that the following method should also be exposed statically so we can call it from XML.
+   *
+   * @returns The decorated method
+   */
+  _exports.implementInterface = implementInterface;
+  function xmlEventHandler() {
+    return function (target, propertykey) {
+      const currentConstructor = target.constructor;
+      currentConstructor[propertykey.toString()] = function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        if (args && args.length) {
+          const currentTarget = currentConstructor.getAPI(args[0]);
+          currentTarget === null || currentTarget === void 0 ? void 0 : currentTarget[propertykey.toString()](...args);
+        }
+      };
+    };
+  }
+
+  /**
+   * Indicates that the following class should define a UI5 control of the specified name.
+   *
+   * @param sTarget The fully qualified name of the UI5 class
+   * @param metadataDefinition Inline metadata definition
+   * @class
+   */
+  _exports.xmlEventHandler = xmlEventHandler;
+  function defineUI5Class(sTarget, metadataDefinition) {
+    return function (constructor) {
+      if (!constructor.prototype.metadata) {
+        constructor.prototype.metadata = {};
+      }
+      if (metadataDefinition) {
+        for (const key in metadataDefinition) {
+          constructor.prototype.metadata[key] = metadataDefinition[key];
+        }
+      }
+      return registerUI5Metadata(constructor, sTarget, constructor.prototype);
+    };
+  }
+  _exports.defineUI5Class = defineUI5Class;
+  function createReference() {
+    return {
+      current: undefined,
+      setCurrent: function (oControlInstance) {
+        this.current = oControlInstance;
+      }
+    };
+  }
+  /**
+   * Defines that the following object will hold a reference to a control through jsx templating.
+   *
+   * @returns The decorated property.
+   */
+  _exports.createReference = createReference;
+  function defineReference() {
+    return function (target, propertyKey, propertyDescriptor) {
+      delete propertyDescriptor.writable;
+      delete propertyDescriptor.initializer;
+      propertyDescriptor.initializer = createReference;
+      return propertyDescriptor;
+    }; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;
+  }
+
+  /**
+   * 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
+   */
+  _exports.defineReference = defineReference;
+  function registerUI5Metadata(clazz, name, inObj) {
+    var _clazz$getMetadata, _inObj$metadata, _clazz$metadata, _obj$metadata;
+    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;
+          //		Log.error(`Property ${objName} from ${name} should be decorated as public`);
+        }
+      });
+    }
+
+    const obj = {};
+    obj.metadata = inObj.metadata || {};
+    obj.override = inObj.override;
+    obj.constructor = clazz;
+    obj.metadata.baseType = Object.getPrototypeOf(clazz.prototype).getMetadata().getName();
+    if ((clazz === null || clazz === void 0 ? void 0 : (_clazz$getMetadata = clazz.getMetadata()) === null || _clazz$getMetadata === void 0 ? void 0 : _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 = inObj.metadata) === null || _inObj$metadata === void 0 ? void 0 : _inObj$metadata.interfaces) || ((_clazz$metadata = clazz.metadata) === null || _clazz$metadata === void 0 ? void 0 : _clazz$metadata.interfaces);
+    Object.keys(clazz.prototype).forEach(key => {
+      if (key !== "metadata") {
+        try {
+          obj[key] = clazz.prototype[key];
+        } catch (e) {
+          //console.log(e);
+        }
+      }
+    });
+    if ((_obj$metadata = obj.metadata) !== null && _obj$metadata !== void 0 && _obj$metadata.controllerExtensions && Object.keys(obj.metadata.controllerExtensions).length > 0) {
+      for (const cExtName in obj.metadata.controllerExtensions) {
+        obj[cExtName] = obj.metadata.controllerExtensions[cExtName];
+      }
+    }
+    const output = clazz.extend(name, obj);
+    const fnInit = output.prototype.init;
+    output.prototype.init = function () {
+      if (fnInit) {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        fnInit.apply(this, args);
+      }
+      this.metadata = obj.metadata;
+      if (obj.metadata.properties) {
+        const aPropertyKeys = Object.keys(obj.metadata.properties);
+        aPropertyKeys.forEach(propertyKey => {
+          Object.defineProperty(this, propertyKey, {
+            configurable: true,
+            set: v => {
+              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 => {
+              return this.setAggregation(aggregationKey, v);
+            },
+            get: () => {
+              const aggregationContent = this.getAggregation(aggregationKey);
+              if (obj.metadata.aggregations[aggregationKey].multiple) {
+                return aggregationContent || [];
+              } else {
+                return aggregationContent;
+              }
+            }
+          });
+        });
+        const aAssociationKeys = Object.keys(obj.metadata.associations);
+        aAssociationKeys.forEach(associationKey => {
+          Object.defineProperty(this, associationKey, {
+            configurable: true,
+            set: v => {
+              return this.setAssociation(associationKey, v);
+            },
+            get: () => {
+              const aggregationContent = this.getAssociation(associationKey);
+              if (obj.metadata.associations[associationKey].multiple) {
+                return aggregationContent || [];
+              } else {
+                return aggregationContent;
+              }
+            }
+          });
+        });
+      }
+    };
+    clazz.override = function (oExtension) {
+      const pol = {};
+      pol.constructor = function () {
+        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+          args[_key3] = arguments[_key3];
+        }
+        return clazz.apply(this, args);
+      };
+      const oClass = Metadata.createClass(clazz, `anonymousExtension~${uid()}`, pol, ControllerMetadata);
+      oClass.getMetadata()._staticOverride = oExtension;
+      oClass.getMetadata()._override = clazz.getMetadata()._override;
+      return oClass;
+    };
+    ObjectPath.set(name, output);
+    return output;
+  }
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ensureMetadata","target","metadata","merge","controllerExtensions","properties","aggregations","associations","methods","events","interfaces","methodOverride","extensionName","propertyKey","override","currentTarget","extension","toString","extensible","overrideExecutionType","overrideExecution","publicExtension","descriptor","enumerable","public","privateExtension","finalExtension","final","usingExtension","extensionClass","propertyDescriptor","initializer","event","eventKey","property","attributeDefinition","writable","aggregation","aggregationDefinition","multiple","undefined","isDefault","defaultAggregation","association","ui5AssociationMetadata","implementInterface","interfaceName","push","xmlEventHandler","propertykey","currentConstructor","constructor","args","length","getAPI","defineUI5Class","sTarget","metadataDefinition","prototype","key","registerUI5Metadata","createReference","current","setCurrent","oControlInstance","defineReference","clazz","name","inObj","getMetadata","isA","Object","getOwnPropertyNames","forEach","objName","getOwnPropertyDescriptor","obj","baseType","getPrototypeOf","getName","getStereotype","rendererDefinition","renderer","render","apiVersion","keys","e","cExtName","output","extend","fnInit","init","apply","aPropertyKeys","defineProperty","configurable","set","v","setProperty","get","getProperty","aAggregationKeys","aggregationKey","setAggregation","aggregationContent","getAggregation","aAssociationKeys","associationKey","setAssociation","getAssociation","oExtension","pol","oClass","Metadata","createClass","uid","ControllerMetadata","_staticOverride","_override","ObjectPath"],"sourceRoot":".","sources":["ClassSupport.ts"],"sourcesContent":["import merge from \"sap/base/util/merge\";\nimport ObjectPath from \"sap/base/util/ObjectPath\";\nimport uid from \"sap/base/util/uid\";\nimport type UI5Event from \"sap/ui/base/Event\";\nimport Metadata from \"sap/ui/base/Metadata\";\nimport type ControllerExtension from \"sap/ui/core/mvc/ControllerExtension\";\nimport ControllerMetadata from \"sap/ui/core/mvc/ControllerMetadata\";\nimport type OverrideExecution from \"sap/ui/core/mvc/OverrideExecution\";\n\ntype OverrideDefinition = Record<string, Function>;\ntype UI5ControllerMethodDefinition = {\n\toverrideExecution?: OverrideExecution;\n\tpublic?: boolean;\n\tfinal?: boolean;\n};\ntype UI5PropertyMetadata = {\n\ttype: string;\n\trequired?: boolean;\n\tgroup?: string;\n\tdefaultValue?: any;\n\texpectedAnnotations?: string[];\n\texpectedTypes?: string[];\n};\ntype UI5AggregationMetadata = {\n\ttype: string;\n\tmultiple?: boolean;\n\tisDefault?: boolean;\n\tsingularName?: string;\n\tvisibility?: string;\n};\ntype UI5AssociationMetadata = {\n\ttype: string;\n\tmultiple?: boolean;\n\tsingularName?: string;\n};\ntype UI5ControlMetadataDefinition = {\n\tdefaultAggregation?: string;\n\tcontrollerExtensions: Record<string, typeof ControllerExtension | Function>;\n\tproperties: Record<string, UI5PropertyMetadata>;\n\taggregations: Record<string, UI5AggregationMetadata>;\n\tassociations: Record<string, UI5AssociationMetadata>;\n\tmethods: Record<string, UI5ControllerMethodDefinition>;\n\tevents: Record<string, {}>;\n\tinterfaces: string[];\n};\ntype UI5Controller = {\n\toverride?: { extension?: Record<string, OverrideDefinition> } & {\n\t\t[k: string]: Function;\n\t};\n\tmetadata?: UI5ControlMetadataDefinition;\n};\n\ntype UI5Control = {\n\tmetadata?: UI5ControlMetadataDefinition;\n};\n\ntype UI5APIControl = UI5Control & {\n\tgetAPI(event: UI5Event): UI5APIControl;\n\t[k: string]: Function;\n};\n\ntype ControlPropertyNames<T> = {\n\t[K in keyof T]: T[K] extends Function ? never : K;\n}[keyof T];\nexport type PropertiesOf<T> = Partial<Pick<T, ControlPropertyNames<T>>>;\nexport type StrictPropertiesOf<T> = Pick<T, ControlPropertyNames<T>>;\nexport type EnhanceWithUI5<T> = {\n\tnew (props: PropertiesOf<T>): EnhanceWithUI5<T>;\n\tnew (sId: string, props: PropertiesOf<T>): EnhanceWithUI5<T>;\n} & T & {\n\t\t// Add all the getXXX method, might add too much as I'm not filtering on actual properties...\n\t\t[P in keyof T as `get${Capitalize<string & P>}`]: () => T[P];\n\t};\nconst ensureMetadata = function (target: UI5Controller) {\n\ttarget.metadata = merge(\n\t\t{\n\t\t\tcontrollerExtensions: {},\n\t\t\tproperties: {},\n\t\t\taggregations: {},\n\t\t\tassociations: {},\n\t\t\tmethods: {},\n\t\t\tevents: {},\n\t\t\tinterfaces: []\n\t\t},\n\t\ttarget.metadata || {}\n\t) as UI5ControlMetadataDefinition;\n\treturn target.metadata;\n};\n\n/* #region CONTROLLER EXTENSIONS */\n\n/**\n * Defines that the following method is an override for the method name with the same name in the specific controller extension or base implementation.\n *\n * @param extensionName The name of the extension that will be overridden\n * @returns The decorated method\n */\nexport function methodOverride(extensionName?: string): MethodDecorator {\n\treturn function (target: UI5Controller, propertyKey) {\n\t\tif (!target.override) {\n\t\t\ttarget.override = {};\n\t\t}\n\t\tlet currentTarget = target.override;\n\t\tif (extensionName) {\n\t\t\tif (!currentTarget.extension) {\n\t\t\t\tcurrentTarget.extension = {};\n\t\t\t}\n\t\t\tif (!currentTarget.extension[extensionName]) {\n\t\t\t\tcurrentTarget.extension[extensionName] = {};\n\t\t\t}\n\t\t\tcurrentTarget = currentTarget.extension[extensionName];\n\t\t}\n\t\tcurrentTarget[propertyKey.toString()] = (target as any)[propertyKey.toString()];\n\t};\n}\n\n/**\n * Defines that the method can be extended by other controller extension based on the defined overrideExecutionType.\n *\n * @param overrideExecutionType The OverrideExecution defining when the override should run (Before / After / Instead)\n * @returns The decorated method\n */\nexport function extensible(overrideExecutionType?: OverrideExecution): MethodDecorator {\n\treturn function (target: UI5Controller, propertyKey) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tif (!metadata.methods[propertyKey.toString()]) {\n\t\t\tmetadata.methods[propertyKey.toString()] = {};\n\t\t}\n\t\tmetadata.methods[propertyKey.toString()].overrideExecution = overrideExecutionType;\n\t};\n}\n\n/**\n * Defines that the method will be publicly available for controller extension usage.\n *\n * @returns The decorated method\n */\nexport function publicExtension(): MethodDecorator {\n\treturn function (target: UI5Controller, propertyKey, descriptor): void {\n\t\tconst metadata = ensureMetadata(target);\n\t\tdescriptor.enumerable = true;\n\t\tif (!metadata.methods[propertyKey.toString()]) {\n\t\t\tmetadata.methods[propertyKey.toString()] = {};\n\t\t}\n\t\tmetadata.methods[propertyKey.toString()].public = true;\n\t};\n}\n/**\n * Defines that the method will be only available for internal usage of the controller extension.\n *\n * @returns The decorated method\n */\nexport function privateExtension(): MethodDecorator {\n\treturn function (target: UI5Controller, propertyKey, descriptor) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tdescriptor.enumerable = true;\n\t\tif (!metadata.methods[propertyKey.toString()]) {\n\t\t\tmetadata.methods[propertyKey.toString()] = {};\n\t\t}\n\t\tmetadata.methods[propertyKey.toString()].public = false;\n\t};\n}\n/**\n * Defines that the method cannot be further extended by other controller extension.\n *\n * @returns The decorated method\n */\nexport function finalExtension(): MethodDecorator {\n\treturn function (target: UI5Controller, propertyKey, descriptor) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tdescriptor.enumerable = true;\n\t\tif (!metadata.methods[propertyKey.toString()]) {\n\t\t\tmetadata.methods[propertyKey.toString()] = {};\n\t\t}\n\t\tmetadata.methods[propertyKey.toString()].final = true;\n\t};\n}\n\n/**\n * Defines that we are going to use instantiate a controller extension under the following variable name.\n *\n * @param extensionClass The controller extension that will be instantiated\n * @returns The decorated property\n */\nexport function usingExtension(extensionClass: typeof ControllerExtension | Function): PropertyDecorator {\n\treturn function (target: UI5Controller, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tdelete (propertyDescriptor as any).initializer;\n\t\tmetadata.controllerExtensions[propertyKey.toString()] = extensionClass;\n\t\treturn propertyDescriptor;\n\t} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if I declare it as such.\n}\n\n/* #endregion */\n\n/* #region CONTROL */\n/**\n * Indicates that the property shall be declared as an event on the control metadata.\n *\n * @returns The decorated property\n */\nexport function event(): PropertyDecorator {\n\treturn function (target: UI5Control, eventKey) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tif (!metadata.events[eventKey.toString()]) {\n\t\t\tmetadata.events[eventKey.toString()] = {};\n\t\t}\n\t};\n}\n\n/**\n * Defines the following property in the control metatada.\n *\n * @param attributeDefinition The property definition\n * @returns The decorated property.\n */\nexport function property(attributeDefinition: UI5PropertyMetadata): PropertyDecorator {\n\treturn function (target: UI5Control, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tif (!metadata.properties[propertyKey]) {\n\t\t\tmetadata.properties[propertyKey] = attributeDefinition;\n\t\t}\n\t\tdelete propertyDescriptor.writable;\n\t\tdelete (propertyDescriptor as any).initializer;\n\n\t\treturn propertyDescriptor;\n\t} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;\n}\n/**\n * Defines and configure the following aggregation in the control metatada.\n *\n * @param aggregationDefinition The aggregation definition\n * @returns The decorated property.\n */\nexport function aggregation(aggregationDefinition: UI5AggregationMetadata): PropertyDecorator {\n\treturn function (target: UI5Control, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tif (aggregationDefinition.multiple === undefined) {\n\t\t\t// UI5 defaults this to true but this is just weird...\n\t\t\taggregationDefinition.multiple = false;\n\t\t}\n\t\tif (!metadata.aggregations[propertyKey]) {\n\t\t\tmetadata.aggregations[propertyKey] = aggregationDefinition;\n\t\t}\n\t\tif (aggregationDefinition.isDefault) {\n\t\t\tmetadata.defaultAggregation = propertyKey;\n\t\t}\n\t\tdelete propertyDescriptor.writable;\n\t\tdelete (propertyDescriptor as any).initializer;\n\n\t\treturn propertyDescriptor;\n\t} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;\n}\n\n/**\n * Defines and configure the following association in the control metatada.\n *\n * @param ui5AssociationMetadata The definition of the association.\n * @returns The decorated property\n */\nexport function association(ui5AssociationMetadata: UI5AssociationMetadata): PropertyDecorator {\n\treturn function (target: UI5Control, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {\n\t\tconst metadata = ensureMetadata(target);\n\t\tif (!metadata.associations[propertyKey]) {\n\t\t\tmetadata.associations[propertyKey] = ui5AssociationMetadata;\n\t\t}\n\t\tdelete propertyDescriptor.writable;\n\t\tdelete (propertyDescriptor as any).initializer;\n\n\t\treturn propertyDescriptor;\n\t} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;\n}\n\n/**\n * Defines in the metadata that this control implements a specific interface.\n *\n * @param interfaceName The name of the implemented interface\n * @returns The decorated method\n */\nexport function implementInterface(interfaceName: string): PropertyDecorator {\n\treturn function (target: UI5Control) {\n\t\tconst metadata = ensureMetadata(target);\n\n\t\tmetadata.interfaces.push(interfaceName);\n\t};\n}\n\n/**\n * Indicates that the following method should also be exposed statically so we can call it from XML.\n *\n * @returns The decorated method\n */\nexport function xmlEventHandler(): MethodDecorator {\n\treturn function (target: UI5Control, propertykey) {\n\t\tconst currentConstructor: UI5APIControl = target.constructor as unknown as UI5APIControl;\n\t\tcurrentConstructor[propertykey.toString()] = function (...args: any[]) {\n\t\t\tif (args && args.length) {\n\t\t\t\tconst currentTarget = currentConstructor.getAPI(args[0] as UI5Event);\n\t\t\t\tcurrentTarget?.[propertykey.toString()](...args);\n\t\t\t}\n\t\t};\n\t};\n}\n\n/**\n * Indicates that the following class should define a UI5 control of the specified name.\n *\n * @param sTarget The fully qualified name of the UI5 class\n * @param metadataDefinition Inline metadata definition\n * @class\n */\nexport function defineUI5Class(sTarget: string, metadataDefinition?: any): ClassDecorator {\n\treturn function (constructor: Function) {\n\t\tif (!constructor.prototype.metadata) {\n\t\t\tconstructor.prototype.metadata = {};\n\t\t}\n\t\tif (metadataDefinition) {\n\t\t\tfor (const key in metadataDefinition) {\n\t\t\t\tconstructor.prototype.metadata[key] = metadataDefinition[key as keyof UI5ControlMetadataDefinition];\n\t\t\t}\n\t\t}\n\t\treturn registerUI5Metadata(constructor, sTarget, constructor.prototype);\n\t};\n}\n\nexport function createReference<T>() {\n\treturn {\n\t\tcurrent: undefined as any as T,\n\t\tsetCurrent: function (oControlInstance: T): void {\n\t\t\tthis.current = oControlInstance;\n\t\t}\n\t};\n}\n/**\n * Defines that the following object will hold a reference to a control through jsx templating.\n *\n * @returns The decorated property.\n */\nexport function defineReference(): PropertyDecorator {\n\treturn function (target: UI5Control, propertyKey: string, propertyDescriptor: TypedPropertyDescriptor<any>) {\n\t\tdelete propertyDescriptor.writable;\n\t\tdelete (propertyDescriptor as any).initializer;\n\t\t(propertyDescriptor as any).initializer = createReference;\n\n\t\treturn propertyDescriptor;\n\t} as any; // This is technically an accessor decorator, but somehow the compiler doesn't like it if i declare it as such.;\n}\n\n/**\n * Internal heavy lifting that will take care of creating the class property for ui5 to use.\n *\n * @param clazz The class prototype\n * @param name The name of the class to create\n * @param inObj The metadata object\n * @returns The metadata class\n */\nfunction registerUI5Metadata(clazz: any, name: string, inObj: any): any {\n\tif (clazz.getMetadata && clazz.getMetadata().isA(\"sap.ui.core.mvc.ControllerExtension\")) {\n\t\tObject.getOwnPropertyNames(inObj).forEach((objName) => {\n\t\t\tconst descriptor = Object.getOwnPropertyDescriptor(inObj, objName);\n\t\t\tif (descriptor && !descriptor.enumerable) {\n\t\t\t\tdescriptor.enumerable = true;\n\t\t\t\t//\t\tLog.error(`Property ${objName} from ${name} should be decorated as public`);\n\t\t\t}\n\t\t});\n\t}\n\tconst obj: any = {};\n\tobj.metadata = inObj.metadata || {};\n\tobj.override = inObj.override;\n\tobj.constructor = clazz;\n\tobj.metadata.baseType = Object.getPrototypeOf(clazz.prototype).getMetadata().getName();\n\n\tif (clazz?.getMetadata()?.getStereotype() === \"control\") {\n\t\tconst rendererDefinition = inObj.renderer || clazz.renderer || clazz.render;\n\t\tobj.renderer = { apiVersion: 2 };\n\t\tif (typeof rendererDefinition === \"function\") {\n\t\t\tobj.renderer.render = rendererDefinition;\n\t\t} else if (rendererDefinition != undefined) {\n\t\t\tobj.renderer = rendererDefinition;\n\t\t}\n\t}\n\tobj.metadata.interfaces = inObj.metadata?.interfaces || clazz.metadata?.interfaces;\n\tObject.keys(clazz.prototype).forEach((key) => {\n\t\tif (key !== \"metadata\") {\n\t\t\ttry {\n\t\t\t\tobj[key] = clazz.prototype[key];\n\t\t\t} catch (e) {\n\t\t\t\t//console.log(e);\n\t\t\t}\n\t\t}\n\t});\n\tif (obj.metadata?.controllerExtensions && Object.keys(obj.metadata.controllerExtensions).length > 0) {\n\t\tfor (const cExtName in obj.metadata.controllerExtensions) {\n\t\t\tobj[cExtName] = obj.metadata.controllerExtensions[cExtName];\n\t\t}\n\t}\n\tconst output = clazz.extend(name, obj);\n\tconst fnInit = output.prototype.init;\n\toutput.prototype.init = function (...args: any[]) {\n\t\tif (fnInit) {\n\t\t\tfnInit.apply(this, args);\n\t\t}\n\t\tthis.metadata = obj.metadata;\n\n\t\tif (obj.metadata.properties) {\n\t\t\tconst aPropertyKeys = Object.keys(obj.metadata.properties);\n\t\t\taPropertyKeys.forEach((propertyKey) => {\n\t\t\t\tObject.defineProperty(this, propertyKey, {\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\tset: (v: any) => {\n\t\t\t\t\t\treturn this.setProperty(propertyKey, v);\n\t\t\t\t\t},\n\t\t\t\t\tget: () => {\n\t\t\t\t\t\treturn this.getProperty(propertyKey);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t});\n\t\t\tconst aAggregationKeys = Object.keys(obj.metadata.aggregations);\n\t\t\taAggregationKeys.forEach((aggregationKey) => {\n\t\t\t\tObject.defineProperty(this, aggregationKey, {\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\tset: (v: any) => {\n\t\t\t\t\t\treturn this.setAggregation(aggregationKey, v);\n\t\t\t\t\t},\n\t\t\t\t\tget: () => {\n\t\t\t\t\t\tconst aggregationContent = this.getAggregation(aggregationKey);\n\t\t\t\t\t\tif (obj.metadata.aggregations[aggregationKey].multiple) {\n\t\t\t\t\t\t\treturn aggregationContent || [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn aggregationContent;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t});\n\t\t\tconst aAssociationKeys = Object.keys(obj.metadata.associations);\n\t\t\taAssociationKeys.forEach((associationKey) => {\n\t\t\t\tObject.defineProperty(this, associationKey, {\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\tset: (v: any) => {\n\t\t\t\t\t\treturn this.setAssociation(associationKey, v);\n\t\t\t\t\t},\n\t\t\t\t\tget: () => {\n\t\t\t\t\t\tconst aggregationContent = this.getAssociation(associationKey);\n\t\t\t\t\t\tif (obj.metadata.associations[associationKey].multiple) {\n\t\t\t\t\t\t\treturn aggregationContent || [];\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn aggregationContent;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t});\n\t\t}\n\t};\n\tclazz.override = function (oExtension: any) {\n\t\tconst pol = {};\n\t\t(pol as any).constructor = function (...args: any[]) {\n\t\t\treturn clazz.apply(this, args as any);\n\t\t};\n\t\tconst oClass = (Metadata as any).createClass(clazz, `anonymousExtension~${uid()}`, pol, ControllerMetadata);\n\t\toClass.getMetadata()._staticOverride = oExtension;\n\t\toClass.getMetadata()._override = clazz.getMetadata()._override;\n\t\treturn oClass;\n\t};\n\n\tObjectPath.set(name, output);\n\treturn output;\n}\n"],"mappings":"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"}