Formelsammlung effektiv ausbauen und Eingaben kontrollieren

[AngularTool]

Moin Moin,

bevor mich die JavaScript Puristen killen, ich komme aus der C# Ecke und setzte auf Angular auf.

Mittlerweile habe ich begriffen und halte es für SUPER GUT, dass JS Funktionen Fist-Class-Objekte sind.

Aber mit der Implementierung von Berechnungsformel habe ich so meine Probleme.

Beispiel:

Ich habe 2 Services in Angular

Service 1) variable-template.service.ts (Funktioniert so wie ich will)

import {Injectable} from '@angular/core';

@Injectable({
  providedIn: 'root'
})
export class VariableTemplateService {

get unit(): string { return this._unit;}
set unit(value: string) { this._unit = value;}

get scale(): number { return this._scale;}
set scale(value: number) { this._scale = value;}

constructor(
    unit: string = null,
    scale: number = 1,
) {
    this._scale = scale;
    this._unit = unit;
  }
}

---

Service 2) unit-converter.service.ts (Sollen eigentlich Logic-Funktionen sein)

import {Injectable} from '@angular/core';

@Injectable({
  providedIn: 'root'
})
export class UnitConverterService {

  public mmUnit = 1;

public unit_mm(unit: string,
               scale: number = 1): any {

  switch (unit) {
    case 'mm':
      return {
        unit: 'cm',
        scale: this.cmUnit
      };

    case 'cm':
      return {unit: 'dm',scale: this.dmUnit,};

   case 'dm':
      return {unit: 'm', scale: this.mUnit,};

    case 'm':
      return {unit: 'mm', scale: this.mmUnit,};

    default:
      return {unit: 'mm',scale: 1,};
  }
}

constructor() {
}  // LEER und kann deshalb keine neue Instanz über ... =new… erstellen

HIER IST MEINE FAGE: WIE KANN ICH DIE FUNKTIONEN (LOGIK UND MATHEFORMELEN SINNVOLL ERSTELLEN?

Die beiden Services baue ich in einer traeger-Tragarm.component.ts ein. Die Templatevariablen (Object Eigenschaften) können „einfach üver den Aufruf new gebildet werden, Die Funtionen aber eben nicht und nur uber einen weitweren Funktionsaufrug (hier ngInit)

import {Component, OnInit} from '@angular/core';
import {VariableTemplateService} from '../../../globales/sevices/SI_Values/variable-template.service';
import {UnitConverterService} from '../../../globales/sevices/SI_Values/unit-converter.service';


@Component({
  selector: 'jg-traeger-tragarm',
  templateUrl: './traeger-tragarm.component.html',
  styleUrls: ['./traeger-tragarm.component.sass']
})

export class TraegerTragarmComponent implements OnInit {

// UND IM CONSTRUCTER MEINE TEMPALTE VARIABLEN BAUE. OK
  constructor(private _UnitConverterService: UnitConverterService,
  ) {
  }

  public F = new VariableTemplateService('N', 1); // HIER DER AUFRUF ÜBER >NEW
  public L = new VariableTemplateService('mm', 1);

// Hier die Funktionsbildung über den weiteren Funktionsaufruf und daher >im constructor private _UnitConverterService: UnitConverterService,

ngOnInit() {
      const unit_mm = this._UnitConverterService.unit_mm;
    }

Hier frage ich mich, wie kann ich eine Variable (Objekteigenschft) aus der (Template) componente in die Funktion - kommend aus dem Service- übergeben, dort berechenen werden? Dann soll wiederum das Ergebnis wieder an die (Tempate) Componente (wohl über RETURN) übergeben werden. Ich habe nur Service Beispiele gesehen, wo der Service eine STATISCHES Object (JSON oder DB) hat, dass dann an die aufrufende Componente per RETURN übergeben wird.