protected Indexer addBaseIndexer(ref ExtClass baseObjectClass)
{
string[] baseObjectClassIndexerDocs = this.processor.GenerateJsDocs
? new string[] {
"Any other property or method.",
"@see https://github.com/microsoft/TypeScript/issues/3755"
}
: null;
Indexer baseIndexer = new Indexer(
"others",
new List <string>()
{
"string"
},
new List <string>()
{
"any"
},
baseObjectClassIndexerDocs,
baseObjectClass.Name.FullName,
true
);
baseObjectClass.AddMemberIndexer(baseIndexer);
return(baseIndexer);
}
protected ExtClass generateDefinitionsClassesTryToFindTheSameMethodClass(ExtClass standardClass, string methodName)
{
ExtClass currentClass = standardClass;
ExtClass parentClass;
Store store = this.processor.Store;
ExtClass result = null;
while (true)
{
if (currentClass.Members.Methods.ContainsKey(methodName))
{
result = currentClass;
break;
}
if (currentClass.Extends == null)
{
break;
}
parentClass = store.GetParentClassByCurrentClassFullName(currentClass.Name.FullName);
if (parentClass == null)
{
break;
}
currentClass = parentClass;
}
return(result);
}
protected void generateBrowserGlobalProxyClass(string browserGlobalClass, bool addAnyOtherMemberIndexer = false)
{
// Generate global class extended from browser global "Object" to be able
// extend this global browser Object from any namespace:
string extGlobalClassName = SpecialsGenerator.GLOBAL_CLASS_BASE
.Replace("<browserGlobalClassName>", browserGlobalClass);
ExtClass baseObjectClass = new ExtClass(
extGlobalClassName, browserGlobalClass, new string[] {
$"Browser's global `{browserGlobalClass}` definition proxy class ",
$"for classes in `Ext.*` namespace(s) to not pointing to `Ext.{browserGlobalClass}`."
}
);
baseObjectClass.Package = ExtJsPackage.CORE;
//baseObjectClass.SrcJson = "Generator";
baseObjectClass.Name.PackagedNamespace = this.processor.Reader.GetPackagedNamespaceFromFullClassName(
extGlobalClassName
);
baseObjectClass.ClassType = ClassType.CLASS_ALIAS;
if (addAnyOtherMemberIndexer)
{
this.addBaseIndexer(ref baseObjectClass);
}
this.processor.Store.AddExtClass(baseObjectClass);
}
protected Property generateDefinitionsClassesTryToFindTheSameProp(ExtClass standardClass, string propName)
{
ExtClass currentClass = standardClass;
ExtClass parentClass;
Store store = this.processor.Store;
Property result = null;
while (true)
{
if (currentClass.Members.Properties.ContainsKey(propName))
{
result = currentClass.Members.Properties[propName] as Property;
break;
}
if (currentClass.Extends == null)
{
break;
}
parentClass = store.GetParentClassByCurrentClassFullName(currentClass.Name.FullName);
if (parentClass == null)
{
break;
}
currentClass = parentClass;
}
return(result);
}
static Ex1()
{
ExtClass.create("Ext.Carousel", new
{
fullscreen = true,
defaults = new { styleHtmlContent = true },
items = new object[]
{
new
{
html = "Item 1",
style = "background-color= #5E99CC"
},
new
{
html = "Item 2",
style = "background-color= #759E60"
},
new
{
html = "Item 3"
}
}
});
}
protected internal bool GenerateConfigurationsInterfaces(specialsGeneratorProgressHandler progressHandler)
{
ExtClass baseConfigInterface = this.addBaseInterface(
SpecialsGenerator.BASE_CONFIGS_INTERFACE_NAME,
"Base configurations interface.",
ClassType.CLASS_CONFIGS
);
this.addBaseIndexer(ref baseConfigInterface);
int processedClassesCount = 0;
ExtClass configClass;
Store store = this.processor.Store;
ExtClass extBaseClass = store.GetByFullName("Ext.Base");
if (extBaseClass == null)
{
throw new Exception("Class `Ext.Base` not found!");
}
foreach (ExtClass standardClass in store.ExtStandardClasses)
{
if (standardClass.Members.Configations.Count > 0)
{
configClass = new ExtClass(
standardClass.Name.FullName + SpecialsGenerator.CONFIGS_NAME_ADDITION,
SpecialsGenerator.BASE_CONFIGS_INTERFACE_NAME,
standardClass.Docs
);
configClass.Package = standardClass.Package;
//configClass.SrcJson = standardClass.SrcJson;
configClass.Name.PackagedNamespace = standardClass.Name.PackagedNamespace;
configClass.ClassType = ClassType.CLASS_CONFIGS;
configClass.Link = new string[] {
standardClass.Name.FullName,
this.processor.Reader.GetLinkHrefForClass(
standardClass.Name.FullName
)
};
foreach (var confMemberItem in standardClass.Members.Configations)
{
configClass.Members.Configations.Add(
confMemberItem.Key,
(confMemberItem.Value as Configuration).Clone()
);
}
// Add only template methods:
this.generateConfigurationsInterfacesTemplateMethods(
standardClass, ref configClass
);
// Add only instance methods from Ext.Base:
this.generateConfigurationsInterfacesExtBaseMethods(
standardClass, extBaseClass, ref configClass
);
configClass.HasMembers = true;
store.AddExtClass(configClass);
}
processedClassesCount += 1;
progressHandler.Invoke(processedClassesCount, standardClass.Name.FullName);
}
return(true);
}
protected void generateConfigurationsInterfacesTemplateMethods(ExtClass standardClass, ref ExtClass configClass)
{
List <Member> methodMemberVariants;
Method firstMethodVariant;
foreach (var methodMemberItem in standardClass.Members.Methods)
{
firstMethodVariant = methodMemberItem.Value.FirstOrDefault <Member>() as Method;
if (!firstMethodVariant.IsTemplate)
{
continue;
}
methodMemberVariants = new List <Member>();
Method newMethodVariant;
foreach (var methodVariant in methodMemberItem.Value)
{
newMethodVariant = (methodVariant as Method).Clone();
newMethodVariant.OwnedByCurrent = true; // always render js docs for config interfaces, there is no inheritance
methodMemberVariants.Add(newMethodVariant);
}
configClass.Members.Methods.Add(
methodMemberItem.Key,
methodMemberVariants
);
}
}
protected string generateMethodWithPropFlags(ExtClass extClass, Method methodVariant, Property mixedProp)
{
string result = "";
// UPDATE for constructing .Def classes: do not render access modifiers anywhere!
/*
* if (methodVariant.AccessModTs == AccessModifier.NONE)
* methodVariant.AccessModTs = methodVariant.AccessModJs;
* if (methodVariant.AccessModTs == AccessModifier.NONE)
* methodVariant.AccessModTs = AccessModifier.PUBLIC;
* if (mixedProp.AccessModTs == AccessModifier.NONE)
* mixedProp.AccessModTs = mixedProp.AccessModJs;
* if (mixedProp.AccessModTs == AccessModifier.NONE)
* mixedProp.AccessModTs = AccessModifier.PUBLIC;
* int methodVariantAcVal = (int)methodVariant.AccessModTs;
* int mixedPropAcVal = (int)mixedProp.AccessModTs;
* if (methodVariantAcVal > mixedPropAcVal) {
* result = methodVariant.AccessModTs.ToString();
* } else if (mixedPropAcVal > methodVariantAcVal) {
* result = mixedProp.AccessModTs.ToString();
* } else {
* result = mixedProp.AccessModTs.ToString();
* }
* result = result.ToLower();
* if (methodVariant.IsStatic || mixedProp.IsStatic)
* result += " static";
*/
if (methodVariant.IsStatic || mixedProp.IsStatic)
{
result = "static";
}
return(result);
}
protected string generateMethodFlags(ExtClass extClass, Method methodVariant)
{
List <string> flags = new List <string>();
// UPDATE for constructing .Def classes: do not render access modifiers anywhere!
/*
* if (methodVariant.AccessModTs == AccessModifier.NONE)
* methodVariant.AccessModTs = methodVariant.AccessModJs;
* if (methodVariant.AccessModTs == AccessModifier.NONE)
* methodVariant.AccessModTs = AccessModifier.PUBLIC;
* flags.Add(AccessModifiers.Values[methodVariant.AccessModTs]);
*/
if (methodVariant.IsStatic || extClass.Name.FullName == "Ext")
{
flags.Add("static");
}
string result = String.Join(" ", flags);
if (flags.Count > 0)
{
result += " ";
}
return(result);
}
protected void generateInterfaceStaticPropertiesAndMethods(ExtClass extClass)
{
bool priv = this.processor.GeneratePrivateMembers;
// Generate static properties:
this.generateProperties(extClass, false, false, AccessModifier.PUBLIC, AccessModifier.PUBLIC);
this.generateProperties(extClass, false, false, AccessModifier.PUBLIC, AccessModifier.PROTECTED);
if (priv)
{
this.generateProperties(extClass, false, false, AccessModifier.PUBLIC, AccessModifier.PRIVATE);
}
this.generateProperties(extClass, false, false, AccessModifier.PROTECTED, AccessModifier.PROTECTED);
if (priv)
{
this.generateProperties(extClass, false, false, AccessModifier.PROTECTED, AccessModifier.PRIVATE);
}
// this.generateClassProperties(extClass, false, false,AccessModifier.PRIVATE, AccessModifier.PRIVATE);
// Generate static methods:
this.generateMethods(extClass, false, false, AccessModifier.PUBLIC, AccessModifier.PUBLIC);
this.generateMethods(extClass, false, false, AccessModifier.PUBLIC, AccessModifier.PROTECTED);
if (priv)
{
this.generateMethods(extClass, false, false, AccessModifier.PUBLIC, AccessModifier.PRIVATE);
}
this.generateMethods(extClass, false, false, AccessModifier.PROTECTED, AccessModifier.PROTECTED);
if (priv)
{
this.generateMethods(extClass, false, false, AccessModifier.PROTECTED, AccessModifier.PRIVATE);
}
// this.generateClassMethods(extClass, false, false, AccessModifier.PRIVATE, AccessModifier.PRIVATE);
}
protected void generateClassOpen(ExtClass extClass)
{
string line = "";
if (!extClass.Name.IsInModule)
{
line += "declare ";
}
if ((extClass.Singleton && extClass.Name.FullName != "Ext") /*|| extClass.ClassType == ClassType.CLASS_DEFINITIONS*/)
{
// Render singleton classes as interfaces and public static props on classes named as it's namespace:
line += "interface " + extClass.Name.ClassName;
}
else
{
// Render standard non-singleton classes in standard way:
line += "class " + extClass.Name.ClassName;
}
if (extClass.Extends != null)
{
line += " extends " + this.checkBrowserGlobalClass(extClass.Extends.FullName);
}
line += " {";
this.writeResultLine(line);
this.whileSpaceLevel += 1;
}
protected string getClassOptimalizedNamespaceName(ExtClass extClass, List <List <string> > packageOptimalizedNs)
{
string packagedNs = extClass.Name.PackagedNamespace;
List <string> packagedNsExploded = packagedNs.Split('.').ToList <string>();
// Select namespaces level to use by namespace parts count:
int namespacesIndex = packagedNsExploded.Count;
// Select optimalized namespaces:
List <string> packageOptimalizedNsInLevel = packageOptimalizedNs[namespacesIndex];
// Check if optimalized namespaces in level has current class namespace
// and if not, use the last namespace, because it's always the other namespace
if (packageOptimalizedNsInLevel.Contains(packagedNs))
{
return(packagedNs);
}
// If there is no optimalized amespace for class, try
// to remove tha last namespace part and try to find
// the "name.space.other" namespace for class:
string namespaceOther = this.getNsLevelOtherNamespace(
packagedNsExploded, packageOptimalizedNsInLevel, extClass.Name.FullName
);
if (packageOptimalizedNsInLevel.Contains(namespaceOther))
{
return(namespaceOther);
}
return(packageOptimalizedNsInLevel.LastOrDefault <string>());
}
protected void readAndAddCfgOrProp(ref ExtClass extClass, ExtObjectMember member, string currentClassName, bool cfgsCompleting)
{
string name = this.sanitizeName(member.Name);
ParsedTypes types = this.typesParser.Parse(
cfgsCompleting
? TypeDefinitionPlace.CONFIGURATION
: TypeDefinitionPlace.PROPERTY,
currentClassName,
member.Name,
member.Type
);
bool ownedByCurrent = member.Owner.Length == currentClassName.Length && member.Owner == currentClassName;
string rawDocs = String.IsNullOrEmpty(member.Doc) ? "" : member.Doc;
bool required = member.Required.HasValue
? member.Required == true
: rawDocs.Contains("(required)");
if (cfgsCompleting)
{
this.readAndAddCfg(
ref extClass, member, types, ownedByCurrent, required
);
}
else
{
this.readAndAddProp(
ref extClass, member, types, ownedByCurrent, required
);
}
}
protected void readAndAddProp(ref ExtClass extClass, ExtObjectMember member, ParsedTypes types, bool ownedByCurrent, bool required)
{
string name = this.sanitizeName(member.Name);
string[] docs = this.readJsDocs(member.Doc, JsDocsType.PROPERTY, extClass.Name.FullName, name);
//if (extClass.Name.FullName == "Ext.Base")
// Debugger.Break();
Property newPropItem = new Property(
name, types.CfgOrProp, docs, member.Owner, ownedByCurrent
);
//newPropItem.DefaultValue = String.IsNullOrEmpty(member.Default) ? "" : member.Default;
newPropItem.DefaultValue = member.Default == "" ? "''" : member.Default;
newPropItem.Deprecated = this.readJsDocsDeprecated(
member.Deprecated, extClass.Name.FullName, name
);
newPropItem.AccessModJs = this.readItemAccessModifier(member);
newPropItem.AccessModTs = newPropItem.AccessModJs;
newPropItem.IsStatic = (member.Static.HasValue && member.Static.Value == true);
newPropItem.IsReadOnly = (member.Readonly.HasValue && member.Readonly.Value == true);
if (!newPropItem.IsReadOnly)
{
string nameUpper = name.ToUpper();
if (name == nameUpper && types.CfgOrProp.Count == 1)
{
newPropItem.IsReadOnly = true; // it's looking like some contant:
}
}
newPropItem.Renderable = extClass.Extends == null || name == "self"; // force render if it is class without any parent
extClass.AddMemberProperty(newPropItem);
}
protected string generatePropertyFlags(ExtClass extClass, Property prop, bool classProcessing)
{
List <string> flags = new List <string>();
bool renderedAsSingletonInterface = extClass.Singleton && extClass.Name.FullName != "Ext";
if (classProcessing && !renderedAsSingletonInterface)
{
// UPDATE for constructing .Def classes: do not render access modifiers anywhere!
/*
* if (prop.AccessModTs == AccessModifier.NONE)
* prop.AccessModTs = prop.AccessModJs;
* if (prop.AccessModTs == AccessModifier.NONE)
* prop.AccessModTs = AccessModifier.PUBLIC;
* flags.Add(AccessModifiers.Values[prop.AccessModTs]);
*/
if (prop.IsStatic || extClass.Name.FullName == "Ext")
{
flags.Add("static");
}
if (prop.IsReadOnly)
{
flags.Add("readonly");
}
}
string result = String.Join(" ", flags);
if (flags.Count > 0)
{
result += " ";
}
return(result);
}
protected void generateInterfaceInstanceMethodsNotInConfigs(ExtClass extClass)
{
// Generate all non-private instance methods not in configs (without any access modifier, because we are inside interface):
Dictionary <string, Member> configs = extClass.Members.Configations;
Dictionary <string, List <Member> > methods = extClass.Members.Methods;
Method firstMethodVariant;
foreach (var methodItem in methods)
{
// Method has no variants:
if (methodItem.Value.Count == 0)
{
continue;
}
firstMethodVariant = methodItem.Value[0] as Method;
// If method is constructor - do not render it in config interface object between other methods:
if (firstMethodVariant.IsConstructor)
{
continue;
}
// Mixed template method with config will be rendered between configs,
// so continue to standard rendering only if not mixed:
if (!configs.ContainsKey(firstMethodVariant.Name))
{
// Standard method variants rendering:
this.generateClassMethodVariants(extClass, methodItem.Value, false);
}
}
}
protected void generateEventJsDocs(ExtClass extClass, Event eventVariant)
{
List <string> docLines = new List <string>();
if (eventVariant.Doc != null && eventVariant.Doc.Length > 0)
{
docLines.AddRange(eventVariant.Doc);
}
docLines.Add("@event");
this.generateMemberDocCommentDeprecated(
ref docLines, eventVariant
);
this.generateEventJsDocsParams(eventVariant, ref docLines);
if (docLines.Count == 1)
{
this.writeResultLine("/** " + docLines[0] + " */");
}
else
{
this.writeResultLine("/** ");
foreach (string docLine in docLines)
{
this.writeResultLine(" * " + docLine);
}
this.writeResultLine(" */");
}
}
protected internal void _addExtClass(ExtClass extClass, bool merge = false)
{
//if (extClass == null) Debugger.Break();
int index;
if (this.ExtClassesMap.ContainsKey(extClass.Name.FullName) && merge)
{
index = this.ExtClassesMap[extClass.Name.FullName];
this.ExtAllClasses[index].MergeWithMembers(extClass);
}
else
{
index = this.ExtAllClasses.Count;
this.ExtAllClasses.Add(extClass);
this.ExtClassesMap.Add(extClass.Name.FullName, index);
if (extClass.Extends != null)
{
this.ExtClassesWithParent.Add(index);
}
if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_STANDARD)
{
this.ExtStandardClasses.Add(extClass);
if (extClass.Singleton)
{
this.ExtStandardSingletonClasses.Add(extClass);
}
}
else if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_ALIAS)
{
this.ExtAliasClasses.Add(extClass);
}
else if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_METHOD_PARAM_CALLBACK)
{
this.ExtCallbackClasses.Add(extClass.Name.FullName, extClass);
}
else if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_METHOD_PARAM_CONF_OBJ)
{
this.ExtMethodParamsClasses.Add(extClass);
}
else if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_STATICS)
{
this.ExtStaticsClasses.Add(extClass);
}
else if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_CONFIGS)
{
this.ExtStaticsClasses.Add(extClass);
}
else if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_DEFINITIONS)
{
this.ExtDefinitionsClasses.Add(extClass);
}
else if (extClass.ClassType == ExtTypes.Enums.ClassType.CLASS_EVENTS)
{
this.ExtEventsClasses.Add(extClass);
}
}
}
protected void readAndAddMethod(ref ExtClass extClass, ExtObjectMember extObjectMember, ref FuncParamsSyntaxCollections funcParamsSyntaxCollections, string currentClassName, string methodName, bool ownedByCurrent, bool isStatic)
{
string[] docs = this.readJsDocs(extObjectMember.Doc, JsDocsType.METHOD, currentClassName, methodName);
Method item = new Method(
methodName, funcParamsSyntaxCollections.StandardParamsSyntax, docs, extObjectMember.Owner, ownedByCurrent
);
item.Deprecated = this.readJsDocsDeprecated(
extObjectMember.Deprecated, currentClassName, methodName
);
item.AccessModJs = this.readItemAccessModifier(extObjectMember);
item.AccessModTs = item.AccessModJs;
item.ExistenceReason = ExistenceReasonType.NATURAL;
item.IsStatic = isStatic;
item.IsChainable = (extObjectMember.Chainable.HasValue && extObjectMember.Chainable.Value == true);
item.IsTemplate = (extObjectMember.Template.HasValue && extObjectMember.Template.Value == true);
item.Renderable = extClass.Extends == null || extObjectMember.Name == "statics"; // force render if it is class without any parent
if (item.IsChainable)
{
item.Renderable = true; // always render chanable method with it's return type
item.ReturnTypes.Add(extClass.Name.FullName);
}
else
{
if (extObjectMember.Return != null)
{
item.ReturnTypes = this.readAndAddMethodReturn(
ref extClass, extObjectMember, currentClassName, isStatic
);
}
else
{
item.ReturnTypes.Add("void");
}
}
if (extObjectMember.Return != null && extObjectMember.Return.Doc != null)
{
item.ReturnDocs = this.readJsDocs(
extObjectMember.Return.Doc,
JsDocsType.METHOD_RETURN,
currentClassName,
"return"
);
}
extClass.AddMemberMethod(item);
if (funcParamsSyntaxCollections.SpreadParamsSyntax.Count > 0)
{
// There is necessary to add second method form,
// because there was last param with standard param
// syntax mixed with spread param syntax:
Method itemClone = item.Clone();
itemClone.OwnedByCurrent = item.OwnedByCurrent;
itemClone.Params = funcParamsSyntaxCollections.SpreadParamsSyntax;
extClass.AddMemberMethod(itemClone);
}
}
protected void readFunctionParamConfObjectProperties(string currentClassName, string extParamsPseudoClassName, string eventOrMethodName, string baseClassOrInterfaceFullName, string pseudoClassDoc, IList <MemberParamProperty> funcParamConfObjectProps, bool eventsCompleting, bool isStatic)
{
ConfigProperty funcParamConfObjectPropOther;
ExtClass extParamConfObject = new ExtClass(
extParamsPseudoClassName,
(baseClassOrInterfaceFullName == "Object"
? SpecialsGenerator.BASE_PARAMS_INTERFACE_NAME
: baseClassOrInterfaceFullName),
this.readJsDocs(
pseudoClassDoc,
eventsCompleting
? JsDocsType.EVENT_PARAM_CONF_OBJ
: JsDocsType.METHOD_PARAM_CONF_OBJ,
extParamsPseudoClassName
)
);
extParamConfObject.Package = this.currentPackage.Type;
//extParamConfObject.SrcJson = this.srcJson;
extParamConfObject.Name.PackagedNamespace = this.GetPackagedNamespaceFromFullClassName(
currentClassName
);
if (eventsCompleting)
{
extParamConfObject.Link = new string[] {
currentClassName + "." + eventOrMethodName,
this.GetLinkHrefForClassEvent(
currentClassName, eventOrMethodName
)
};
}
else
{
extParamConfObject.Link = new string[] {
currentClassName + "." + eventOrMethodName,
this.GetLinkHrefForClassMethod(
currentClassName, isStatic, eventOrMethodName
)
};
}
extParamConfObject.ClassType = ClassType.CLASS_METHOD_PARAM_CONF_OBJ;
foreach (MemberParamProperty funcParamConfObjectProp in funcParamConfObjectProps)
{
funcParamConfObjectPropOther = this.readFunctionParamConfObjectProperty(
extParamsPseudoClassName,
pseudoClassDoc,
funcParamConfObjectProp,
eventOrMethodName,
eventsCompleting,
isStatic
);
extParamConfObject.AddMemberProperty(funcParamConfObjectPropOther);
}
this.processor.Store.AddExtClass(extParamConfObject);
}
protected void consolidateParentsCountsOrderForClass(
ref Dictionary <int, Dictionary <int, Dictionary <string, int> > > orderStore,
ref ExtClass extClass
)
{
Dictionary <string, int> extClassesMap = this.processor.Store.ExtClassesMap;
List <ExtClass> extAllClasses = this.processor.Store.ExtAllClasses;
int parentsCount = 0;
int modulePartsCount = 0;
Dictionary <int, Dictionary <string, int> > parentsCountsRecord;
Dictionary <string, int> classesInModuleRecord;
int classMapIndex;
ExtClass recursiveClassItem;
// detect how many parent classes this class have:
recursiveClassItem = extClass;
while (true)
{
if (recursiveClassItem.Extends == null)
{
break;
}
parentsCount += 1;
if (!extClassesMap.ContainsKey(recursiveClassItem.Extends.FullName))
{
// class is extended from some unknown class type,
// so it's not possible to determinate more parent classes:
break;
}
classMapIndex = extClassesMap[recursiveClassItem.Extends.FullName];
recursiveClassItem = extAllClasses[classMapIndex];
extClass.Parents.Add(recursiveClassItem);
}
// detect how complicated is module name:
if (extClass.Name.IsInModule)
{
modulePartsCount = extClass.Name.NamespaceName.Split('.').Length;
}
// prepare order store place:
if (!orderStore.ContainsKey(parentsCount))
{
orderStore.Add(parentsCount, new Dictionary <int, Dictionary <string, int> >());
}
parentsCountsRecord = orderStore[parentsCount];
if (!parentsCountsRecord.ContainsKey(modulePartsCount))
{
parentsCountsRecord.Add(modulePartsCount, new Dictionary <string, int>());
}
classesInModuleRecord = parentsCountsRecord[modulePartsCount];
classesInModuleRecord.Add(
extClass.Name.FullName,
extClassesMap[extClass.Name.FullName]
);
}
protected void generateInterfaceOpenClose(ExtClass extClass)
{
string line = "interface " + extClass.Name.ClassName;
if (extClass.Extends != null)
{
line += " extends " + this.checkBrowserGlobalClass(extClass.Extends.FullName);
}
line += " {}";
this.writeResultLine(line);
}
// used only in class `ExtGlobalObject` and in interfaces `Ext.base.(Cfg|Params|Statics|Events)`
protected void generateMemberIndexer(ExtClass extClass, Indexer indexer)
{
if (this.processor.GenerateJsDocs)
{
this.writeResultLine("/** @indexer */");
}
string line = indexer.IsReadOnly ? "readonly " : "";
line += "[" + indexer.Name + ": " + String.Join(" | ", indexer.KeyTypes) + "]: "
+ this.generateMemberIndexerTypes(indexer) + ";";
this.writeResultLine(line);
}
protected void resolveMethodsExtending(
ref ExtClass currentExtClass,
Dictionary <string, List <Member> > methodsCollection,
bool instanceMethodsProcessing
)
{
bool currentMethodVariantsAreNecessaryToDefine;
string[] methodsCollectionKeys = methodsCollection.Keys.ToArray <string>();
string methodName;
List <Member> currentMethodVariants;
Dictionary <string, List <Member> > methodsTree;
Method firstMethodVariant;
for (int i = 0; i < methodsCollectionKeys.Length; i++)
{
methodName = methodsCollectionKeys[i];
currentMethodVariants = methodsCollection[methodName];
firstMethodVariant = currentMethodVariants.FirstOrDefault <Member>() as Method;
if (firstMethodVariant.IsChainable)
{
methodsCollection[methodName] = this.resolveMethodsExtendingChainableParents(
ref currentExtClass,
ref currentMethodVariants,
instanceMethodsProcessing,
methodName
);
}
else
{
currentMethodVariantsAreNecessaryToDefine = firstMethodVariant.Renderable;
methodsTree = new Dictionary <string, List <Member> >()
{
{ currentExtClass.Name.FullName, currentMethodVariants }
};
this.resolveMethodsExtendingTraverse(
ref currentExtClass,
ref currentMethodVariants,
ref methodsTree,
ref currentMethodVariantsAreNecessaryToDefine,
instanceMethodsProcessing,
methodName
);
methodsCollection[methodName] = this.resolveMethodsExtendingAccessModifiers(
ref currentMethodVariants,
ref methodsTree,
instanceMethodsProcessing,
currentMethodVariantsAreNecessaryToDefine
);
}
}
}
public void Resolve(ref ExtClass extClass)
{
bool hasParents = extClass.Extends == null;
if (hasParents)
{
this.setBaseClassPropsAndMethodsNotInherite(ref extClass);
}
else
{
this.resolveMembersExtending(ref extClass);
}
}
protected void generateMethods(ExtClass extClass, bool instanceMembers, bool classProcessing, AccessModifier typeScriptAccessMod, AccessModifier javascriptAccessMod)
{
Dictionary <string, Member> props = instanceMembers
? extClass.Members.Properties
: extClass.Members.PropertiesStatic;
Dictionary <string, List <Member> > methods = instanceMembers
? extClass.Members.Methods
: extClass.Members.MethodsStatic;
Method firstMethodVariant;
Property mixedProp;
bool renderedAsSingletonInterface = extClass.Singleton && extClass.Name.FullName != "Ext";
foreach (var methodItem in methods)
{
// Method has no variants:
if (methodItem.Value.Count == 0)
{
continue;
}
firstMethodVariant = methodItem.Value[0] as Method;
// Method variants are not necessary to render, they are extended naturaly in the same form:
if (!firstMethodVariant.Renderable)
{
continue;
}
// Method variants are not possible to render, because class is rendered as singleton interface,
// where is not possible to render inherited method variants:
if (renderedAsSingletonInterface && firstMethodVariant.Inherited)
{
continue;
}
// If method variants have currently required access modifiers:
if (
(firstMethodVariant.AccessModTs & typeScriptAccessMod) != 0 &&
(firstMethodVariant.AccessModJs & javascriptAccessMod) != 0
)
{
if (props.ContainsKey(firstMethodVariant.Name))
{
// Mixed method variants with property - always caused by two mixins classes:
mixedProp = props[firstMethodVariant.Name] as Property;
this.generateClassMethodVariantsWithProperty(extClass, methodItem.Value, mixedProp, classProcessing);
}
else
{
// Standard method variants rendering:
this.generateClassMethodVariants(extClass, methodItem.Value, classProcessing);
}
}
}
}
protected void generateInterfaceEvent(ExtClass extClass, Event eventVariant)
{
// Generate TypeScript doc comments for standard configuration:
if (this.processor.GenerateJsDocs && !extClass.Private)
{
this.generateEventJsDocs(extClass, eventVariant);
}
// generate TypeScript definition code:
string line = eventVariant.Name + "? ("
+ this.generateMethodParams(extClass, eventVariant.Params)
+ "): void;";
this.writeResultLine(line);
}
protected void generateConfigurationJsDocs(ExtClass extClass, Configuration config)
{
List <string> docLines = new List <string>();
if (config.Doc != null && config.Doc.Length > 0)
{
docLines.AddRange(config.Doc);
}
if (extClass.ClassType == ClassType.CLASS_CONFIGS)
{
docLines.Add("@configuration");
}
if (config.Required)
{
docLines.Add("@required");
}
else
{
docLines.Add("@optional");
}
if (extClass.ClassType == ClassType.CLASS_CONFIGS)
{
if (!String.IsNullOrEmpty(config.DefaultValue))
{
docLines.Add(
"@default " + config.DefaultValue.Replace("*/", "*\\/")
);
}
}
this.generateMemberDocCommentDeprecated(
ref docLines, config
);
this.generateConfigurationDocCommentTypes(
ref docLines, config
);
if (docLines.Count == 1)
{
this.writeResultLine("/** " + docLines[0] + " */");
}
else
{
this.writeResultLine("/** ");
foreach (string docLine in docLines)
{
this.writeResultLine(" * " + docLine);
}
this.writeResultLine(" */");
}
}
protected void generateInterfacePropertyConfiguration(ExtClass extClass, ConfigProperty configProp)
{
if (this.processor.GenerateJsDocs && !extClass.Private)
{
// Generate TypeScript doc comments for standard property:
this.generateConfigPropertyJsDocs(extClass, configProp);
}
// generate TypeScript definition code:
string line = configProp.Name + (configProp.Required ? ": " : "?: ")
+ this.generateConfigPropertyTypes(configProp)
+ ";";
this.writeResultLine(line);
}
protected internal void AddExtClass(ExtClass extClass, bool merge = false)
{
if (this.insideLock)
{
this._addExtClass(extClass, merge);
}
else
{
lock (this.addLock) {
this.insideLock = true;
this._addExtClass(extClass, merge);
this.insideLock = false;
}
}
}
public static bool IsStatic(ExtClass ec, string member) {
if (ec.Name == "DialogManager") return true;
if (ec.Name == "EventObject") return false;
if (ec.Singleton) return true;
return false;
}
