public void LoadAll(List <GenericEntity> items)
        {
            UnloadAll();
            foreach (var item in items)
            {
                if (!GeneratedEntities.Contains(item) || LoadedEntities.Contains(item))
                {
                    continue;
                }

                Load(item, Object.transform);
                LoadedEntities.Add(item);
            }
        }
Esempio n. 2
0
        private void ProcessTypes()
        {
            foreach (var file in TSClass.Select(c => c.FileName).Distinct().OrderBy(c => c))
            {
                var fileName    = file.GetSelector();
                var importItems = TSClass.Where(c => c.FileName == file).SelectMany(c => c.Imports).ToList();

                var builder = new StringBuilderIndented();

                builder
                .GenerateFileMessage();

                if (importItems.Any())
                {
                    var imported = false;

                    foreach (var importFile in importItems.Where(c => c.File != file).Select(c => c.File).Distinct())
                    {
                        imported = true;

                        var classes = importItems.Where(c => c.File == importFile).Select(c => c.Class).Distinct().ToArray();
                        var import  = string.Join(", ", classes);

                        builder
                        .AppendLine($"import {{ {import} }} from \"./{importFile.Replace(".ts", string.Empty)}\";");
                    }

                    if (imported)
                    {
                        builder
                        .AppendLine();
                    }
                }

                foreach (var className in TSClass.Where(c => c.FileName == file).Select(c => c.Class).Distinct().OrderBy(c => c))
                {
                    var tsClass = TSClass
                                  .Where(c => c.FileName == file && c.Class == className)
                                  .FirstOrDefault();

                    var generics = tsClass.Properties
                                   .Where(c => c.Generic)
                                   .Select(c => c.Type)
                                   .ToList();

                    var classNamePrint = tsClass.Class;

                    if (generics.Count > 0)
                    {
                        classNamePrint  = classNamePrint.Substring(0, classNamePrint.IndexOf('`'));
                        classNamePrint += "<";
                        classNamePrint += string.Join(", ", generics);
                        classNamePrint += ">";
                    }

                    builder
                    .AppendLine($"export interface I{classNamePrint} {{")
                    .IncrementIndent();

                    foreach (var property in tsClass.Properties)
                    {
                        var nullable = property.Nullable ? "?" : "";

                        builder
                        .AppendLine($"{property.Name}{nullable}: {property.Type}; ");
                    }

                    builder
                    .DecrementIndent()
                    .AppendLine("}")
                    .AppendLine();
                }

                if (GeneratedEntities.Contains(fileName))
                {
                    throw new Exception($"Two file with same name cannot be generated: {fileName}");
                }

                GeneratedEntities.Add(fileName);
                Writer.WriteFile(Config.TypeScript.Entity.Path.ToLower(), fileName, builder, true);
            }
        }
 public int GeneratedCount() => GeneratedEntities.Count();
 public void Generate(GenericEntity item)
 {
     GeneratedEntities.Add(item);
 }