Refacto: Typescript - Methods are public by default

jhipster · Feb 4, 2025 · 18a6f97 · 18a6f97
1 parent a9478be
commit 18a6f97
Show file tree

Hide file tree

Showing 6 changed files with 51 additions and 51 deletions.
diff --git a/src/main/webapp/app/module/domain/landscape/Landscape.ts b/src/main/webapp/app/module/domain/landscape/Landscape.ts
@@ -300,23 +300,23 @@ export class Landscape {
       .orElse([]);
   }
 
-  public static initialState(levels: LandscapeLevel[]): Landscape {
+  static initialState(levels: LandscapeLevel[]): Landscape {
     return new Landscape(new LandscapeState([], []), new LevelsProjections(levels));
   }
 
-  public standaloneLevels(): LandscapeLevel[] {
+  standaloneLevels(): LandscapeLevel[] {
     return this.projections.levels;
   }
 
-  public resetAppliedModules(appliedModules: ModuleSlug[]): Landscape {
+  resetAppliedModules(appliedModules: ModuleSlug[]): Landscape {
     return new Landscape(this.state.resetAppliedModules(appliedModules), this.projections);
   }
 
-  public appliedModules(appliedModules: ModuleSlug[]): Landscape {
+  appliedModules(appliedModules: ModuleSlug[]): Landscape {
     return new Landscape(this.state.addAppliedModules(appliedModules), this.projections);
   }
 
-  public toggle(module: ModuleSlug): Landscape {
+  toggle(module: ModuleSlug): Landscape {
     if (this.isNotSelectable(module)) {
       return this;
     }
@@ -330,15 +330,15 @@ export class Landscape {
     return !this.isSelectable(module);
   }
 
-  public isSelectable(module: ModuleSlug): boolean {
+  isSelectable(module: ModuleSlug): boolean {
     return this.moduleIs(module, currentModule => currentModule.selectionTree().isSelectable());
   }
 
-  public isApplied(module: ModuleSlug): boolean {
+  isApplied(module: ModuleSlug): boolean {
     return this.moduleIs(module, currentModule => currentModule.isApplied());
   }
 
-  public isSelected(element: LandscapeElementId): boolean {
+  isSelected(element: LandscapeElementId): boolean {
     if (element instanceof ModuleSlug) {
       return this.moduleIs(element, currentModule => currentModule.isSelected());
     }
@@ -357,13 +357,13 @@ export class Landscape {
     return this.getModule(slug).map(operation).orElse(false);
   }
 
-  public selectionTreeFor(module: ModuleSlug): LandscapeSelectionTree {
+  selectionTreeFor(module: ModuleSlug): LandscapeSelectionTree {
     return this.getModule(module)
       .map(currentModule => currentModule.selectionTree())
       .orElse(LandscapeSelectionTree.EMPTY);
   }
 
-  public unselectionTreeFor(module: ModuleSlug): LandscapeUnselectionTree {
+  unselectionTreeFor(module: ModuleSlug): LandscapeUnselectionTree {
     return this.getModule(module)
       .map(currentModule => currentModule.unselectionTree())
       .orElse(LandscapeUnselectionTree.EMPTY);
@@ -373,50 +373,50 @@ export class Landscape {
     return Optional.ofNullable(this.modules.get(module.get()));
   }
 
-  public noNotAppliedSelectedModule(): boolean {
+  noNotAppliedSelectedModule(): boolean {
     return this.notAppliedSelectedModulesCount() === 0;
   }
 
-  public notAppliedSelectedModulesCount(): number {
+  notAppliedSelectedModulesCount(): number {
     return this.getNotAppliedSelectedModuleIds().length;
   }
 
-  public notAppliedSelectedModules(): ModuleSlug[] {
+  notAppliedSelectedModules(): ModuleSlug[] {
     return this.getNotAppliedSelectedModuleIds().map(slug => new ModuleSlug(slug));
   }
 
   private getNotAppliedSelectedModuleIds() {
     return this.state.selectedModules.filter(selectedModule => !this.state.appliedModules.includes(selectedModule));
   }
 
-  public noSelectedModule(): boolean {
+  noSelectedModule(): boolean {
     return this.selectedModulesCount() === 0;
   }
 
-  public selectedModulesCount(): number {
+  selectedModulesCount(): number {
     return this.state.selectedModules.length;
   }
 
-  public selectedModules(): ModuleSlug[] {
+  selectedModules(): ModuleSlug[] {
     return this.state.selectedModules.map(slug => new ModuleSlug(slug));
   }
 
-  public selectedModulesProperties(): ModulePropertyDefinition[] {
+  selectedModulesProperties(): ModulePropertyDefinition[] {
     return this.properties;
   }
 }
 
 class LandscapeState {
   constructor(
-    public readonly appliedModules: ModuleId[],
-    public readonly selectedModules: ModuleId[],
+    readonly appliedModules: ModuleId[],
+    readonly selectedModules: ModuleId[],
   ) {}
 
-  public isApplied(module: ModuleId): boolean {
+  isApplied(module: ModuleId): boolean {
     return this.isModuleIn(module, this.appliedModules);
   }
 
-  public toggle(module: LandscapeModule): LandscapeState {
+  toggle(module: LandscapeModule): LandscapeState {
     if (this.isSelected(module.slugString())) {
       return this.unselectModule(module);
     }
@@ -448,25 +448,25 @@ class LandscapeState {
     return this.selectedModules.filter(selectedModule => !modulesToUnselect.includes(selectedModule));
   }
 
-  public isNotSelected(module: ModuleId): boolean {
+  isNotSelected(module: ModuleId): boolean {
     return !this.isSelected(module);
   }
 
-  public isSelected(module: ModuleId): boolean {
+  isSelected(module: ModuleId): boolean {
     return this.isModuleIn(module, this.selectedModules);
   }
 
   private isModuleIn(module: ModuleId, modules: ModuleId[]): boolean {
     return modules.includes(module);
   }
 
-  public resetAppliedModules(appliedModules: ModuleSlug[]): LandscapeState {
+  resetAppliedModules(appliedModules: ModuleSlug[]): LandscapeState {
     const moduleIds = appliedModules.map(module => module.get());
 
     return new LandscapeState(moduleIds, [...new Set([...moduleIds, ...this.selectedModules])]);
   }
 
-  public addAppliedModules(appliedModules: ModuleSlug[]): LandscapeState {
+  addAppliedModules(appliedModules: ModuleSlug[]): LandscapeState {
     const moduleIds = appliedModules.map(module => module.get());
 
     return new LandscapeState([...this.appliedModules, ...moduleIds], [...new Set([...moduleIds, ...this.selectedModules])]);
@@ -510,27 +510,27 @@ class LevelsProjections {
     );
   }
 
-  public getDependantModules(element: LandscapeElementId): ModuleSlug[] {
+  getDependantModules(element: LandscapeElementId): ModuleSlug[] {
     return this.memoizedDependantModules.get(element.get(), () =>
       Array.from(this.standaloneModules.values())
         .filter(standaloneModule => standaloneModule.dependencies().some(dependency => dependency.get() === element.get()))
         .map(module => module.slug()),
     );
   }
 
-  public mapModules(mapper: (module: LandscapeModule) => LandscapeModule): Map<string, LandscapeModule> {
+  mapModules(mapper: (module: LandscapeModule) => LandscapeModule): Map<string, LandscapeModule> {
     return new Map(Array.from(this.standaloneModules.entries()).map(entry => [entry[0], mapper(entry[1])]));
   }
 
-  public getStandaloneModule(module: ModuleId): Optional<LandscapeModule> {
+  getStandaloneModule(module: ModuleId): Optional<LandscapeModule> {
     return Optional.ofNullable(this.standaloneModules.get(module));
   }
 
-  public getFeature(feature: LandscapeFeatureSlug): Optional<LandscapeFeature> {
+  getFeature(feature: LandscapeFeatureSlug): Optional<LandscapeFeature> {
     return Optional.ofNullable(this.features.get(feature.get()));
   }
 
-  public getModuleFeature(module: ModuleSlug) {
+  getModuleFeature(module: ModuleSlug) {
     return Optional.ofNullable(this.moduleFeatures.get(module.get()));
   }
 }
diff --git a/src/main/webapp/app/module/domain/landscape/LandscapeFeature.ts b/src/main/webapp/app/module/domain/landscape/LandscapeFeature.ts
@@ -8,15 +8,15 @@ export class LandscapeFeature implements LandscapeElement {
     public readonly modules: LandscapeModule[],
   ) {}
 
-  public slugString(): string {
+  slugString(): string {
     return this.slug().get();
   }
 
-  public slug(): LandscapeFeatureSlug {
+  slug(): LandscapeFeatureSlug {
     return this.featureSlug;
   }
 
-  public allModules(): LandscapeModule[] {
+  allModules(): LandscapeModule[] {
     return this.modules;
   }
 }
diff --git a/src/main/webapp/app/module/domain/landscape/LandscapeFeatureSlug.ts b/src/main/webapp/app/module/domain/landscape/LandscapeFeatureSlug.ts
@@ -1,7 +1,7 @@
 export class LandscapeFeatureSlug {
   constructor(private readonly slug: string) {}
 
-  public get(): string {
+  get(): string {
     return this.slug;
   }
 }
diff --git a/src/main/webapp/app/module/domain/landscape/LandscapeModule.ts b/src/main/webapp/app/module/domain/landscape/LandscapeModule.ts
@@ -33,51 +33,51 @@ export class LandscapeModule implements LandscapeElement {
     private readonly context: LandscapeModuleContext,
   ) {}
 
-  public static initialState(information: LandscapeModuleInformation): LandscapeModule {
+  static initialState(information: LandscapeModuleInformation): LandscapeModule {
     return new LandscapeModule(information, INITIAL_CONTEXT);
   }
 
-  public slugString(): string {
+  slugString(): string {
     return this.slug().get();
   }
 
-  public slug(): ModuleSlug {
+  slug(): ModuleSlug {
     return this.information.slug;
   }
 
-  public dependencies(): LandscapeElementId[] {
+  dependencies(): LandscapeElementId[] {
     return this.information.dependencies;
   }
 
-  public operation(): string {
+  operation(): string {
     return this.information.operation;
   }
 
-  public properties(): ModulePropertyDefinition[] {
+  properties(): ModulePropertyDefinition[] {
     return this.information.properties;
   }
 
-  public allModules(): LandscapeModule[] {
+  allModules(): LandscapeModule[] {
     return [this];
   }
 
-  public inContext(context: LandscapeModuleContext): LandscapeModule {
+  inContext(context: LandscapeModuleContext): LandscapeModule {
     return new LandscapeModule(this.information, context);
   }
 
-  public isSelected(): boolean {
+  isSelected(): boolean {
     return this.context.selected;
   }
 
-  public isApplied(): boolean {
+  isApplied(): boolean {
     return this.context.applied;
   }
 
-  public selectionTree(): LandscapeSelectionTree {
+  selectionTree(): LandscapeSelectionTree {
     return this.context.selectionTree;
   }
 
-  public unselectionTree(): LandscapeUnselectionTree {
+  unselectionTree(): LandscapeUnselectionTree {
     return this.context.unselectionTree;
   }
 }
diff --git a/src/main/webapp/app/module/domain/landscape/LandscapeSelectionTree.ts b/src/main/webapp/app/module/domain/landscape/LandscapeSelectionTree.ts
@@ -3,19 +3,19 @@ import { LandscapeElementId } from './LandscapeElementId';
 import { LandscapeSelectionElement } from './LandscapeSelectionElement';
 
 export class LandscapeSelectionTree {
-  public static readonly EMPTY: LandscapeSelectionTree = new LandscapeSelectionTree([]);
+  static readonly EMPTY: LandscapeSelectionTree = new LandscapeSelectionTree([]);
 
   private readonly selectable: boolean;
 
-  public constructor(public readonly elements: LandscapeSelectionElement[]) {
+  constructor(public readonly elements: LandscapeSelectionElement[]) {
     this.selectable = elements.every(element => element.selectable);
   }
 
-  public isSelectable(): boolean {
+  isSelectable(): boolean {
     return this.selectable;
   }
 
-  public find(element: LandscapeElementId): Optional<LandscapeSelectionElement> {
+  find(element: LandscapeElementId): Optional<LandscapeSelectionElement> {
     return Optional.ofNullable(this.elements.find(selectionElement => selectionElement.slug.get() === element.get()));
   }
 }
diff --git a/src/main/webapp/app/module/domain/landscape/LandscapeUnselectionTree.ts b/src/main/webapp/app/module/domain/landscape/LandscapeUnselectionTree.ts
@@ -5,7 +5,7 @@ export class LandscapeUnselectionTree {
 
   constructor(public readonly elements: LandscapeElementId[]) {}
 
-  public includes(element: LandscapeElementId): boolean {
+  includes(element: LandscapeElementId): boolean {
     return this.elements.some(unselectedElement => unselectedElement.get() === element.get());
   }
 }