Callable und Newable Interfaces

// Call Signature in einem Interface — Doppelpunkt vor dem Return-Typ.
interface Greeter {
  (name: string): string;
}

// Äquivalente Funktions-Typ-Notation — Pfeil vor dem Return-Typ.
type GreeterType = (name: string) => string;

// Beide sind zuweisbar — der Compiler sieht sie als strukturell gleich.
const greetA: Greeter     = (name) => `Hallo, ${name}!`;
const greetB: GreeterType = (name) => `Hallo, ${name}!`;

greetA("Welt");  // "Hallo, Welt!"
greetB("Welt");  // "Hallo, Welt!"

// Interface: callable UND Property-Träger.
interface CachingFn {
  (key: string): string;          // Call Signature
  cache: Map<string, string>;     // Property auf der Funktion selbst
  hits: number;                   // Property, zur Statistik
}

// Konstruktion: zuerst die nackte Funktion, dann die Properties anhängen.
const lookup = ((key: string) => {
  const cached = lookup.cache.get(key);
  if (cached !== undefined) {
    lookup.hits++;                // Property-Zugriff auf die Funktion selbst.
    return cached;
  }
  const computed = key.toUpperCase();
  lookup.cache.set(key, computed);
  return computed;
}) as CachingFn;

lookup.cache = new Map();
lookup.hits  = 0;

lookup("hallo");   // "HALLO"
lookup("hallo");   // "HALLO" (aus dem Cache)
lookup.hits;       // 1

// Die instanzierte Form — was nach `new Clock(...)` herauskommt.
interface Clock {
  hour: number;
  tick(): void;
}

// Die Konstruktor-Form — was VOR `new` steht.
interface ClockConstructor {
  new (h: number): Clock;         // `new` macht das zur Construct Signature.
}

// Eine konkrete Klasse, die der Konstruktor-Form genügt:
class DigitalClock implements Clock {
  hour: number;
  constructor(h: number) { this.hour = h; }
  tick() { this.hour = (this.hour + 1) % 24; }
}

// `DigitalClock` selbst (als Klassen-Referenz) ist der Konstruktor.
const Ctor: ClockConstructor = DigitalClock;
const c = new Ctor(10);           // c: Clock
c.tick();

interface Animal {
  name: string;
  speak(): string;
}

// Construct Signature als Parameter-Typ — beschreibt die Klasse selbst.
type AnimalCtor = new (name: string) => Animal;

// Factory: bekommt die Klasse, gibt eine Instanz zurück.
function makeAnimal(Ctor: AnimalCtor, name: string): Animal {
  return new Ctor(name);
  //     ^^^ erlaubt nur, weil `Ctor` als `new (...) => Animal` getypt ist.
}

class Dog implements Animal {
  constructor(public name: string) {}
  speak() { return `${this.name}: Wuff!`; }
}

class Cat implements Animal {
  constructor(public name: string) {}
  speak() { return `${this.name}: Miau.`; }
}

makeAnimal(Dog, "Rex").speak();    // "Rex: Wuff!"
makeAnimal(Cat, "Mimi").speak();   // "Mimi: Miau."

interface JQueryElement { length: number; /* ... */ }
interface JQueryDeferred { resolve(): void; /* ... */ }

// Das hybride Interface — alles in einem Typ.
interface JQueryStatic {
  // 1) Call Signature — `$("div")` wählt Elemente aus.
  (selector: string): JQueryElement;

  // 2) Construct Signature — `new $.Deferred()` erzeugt ein Deferred.
  new (selector: string): JQueryElement;

  // 3) Property — `$.version` ist ein String.
  version: string;

  // 4) Methode — `$.each(arr, fn)` iteriert.
  each<T>(arr: T[], fn: (i: number, item: T) => void): void;

  // 5) Verschachteltes Property-Objekt — `$.fn.extend(...)`.
  fn: {
    extend(plugin: object): void;
  };
}

declare const $: JQueryStatic;

$("div").length;                // Call Signature
const el = new $("span");       // Construct Signature
$.version;                      // Property
$.each([1, 2, 3], (i, n) => {}); // Methode
$.fn.extend({ myPlugin() {} }); // verschachtelt

// Stringifier: nimmt entweder eine Zahl oder einen Boolean.
interface Stringifier {
  (n: number): string;            // Overload 1 — spezifisch für number
  (b: boolean): string;           // Overload 2 — spezifisch für boolean
}

const stringify: Stringifier = (value: number | boolean) =>
  typeof value === "number" ? value.toFixed(2) : value ? "ja" : "nein";

stringify(3.14);   // "3.14"   — Overload 1
stringify(true);   // "ja"     — Overload 2

// Reihenfolgen-Falle:
interface Bad {
  (x: unknown): string;           // matched ALLES — fataler erster Treffer
  (x: number): string;            // wird nie erreicht
}

// Generisches hybrides Interface: callable + clear-Methode + Statistik.
interface Memoized<Args extends unknown[], R> {
  (...args: Args): R;             // Call Signature mit Spread für beliebige Argumente
  clear(): void;                  // leert den internen Cache
  readonly size: number;          // wie viele Einträge liegen aktuell im Cache
}

function memoize<Args extends unknown[], R>(
  fn: (...args: Args) => R
): Memoized<Args, R> {
  const cache = new Map<string, R>();

  // Innere Funktion deckt die Call Signature ab.
  const wrapped = ((...args: Args): R => {
    const key = JSON.stringify(args);   // simpler Schlüssel — reicht für Primitives
    if (cache.has(key)) return cache.get(key)!;
    const result = fn(...args);
    cache.set(key, result);
    return result;
  }) as Memoized<Args, R>;

  // Properties und Methoden auf das Funktions-Objekt heften.
  wrapped.clear = () => cache.clear();
  Object.defineProperty(wrapped, "size", {
    get: () => cache.size,        // dynamisch — kein Snapshot.
  });

  return wrapped;
}

const slowAdd = (a: number, b: number) => {
  // Simulation einer teuren Berechnung.
  return a + b;
};

const fastAdd = memoize(slowAdd);
fastAdd(1, 2);     // 3  (berechnet)
fastAdd(1, 2);     // 3  (aus dem Cache)
fastAdd.size;      // 1
fastAdd.clear();
fastAdd.size;      // 0

// Vereinfachtes React-Component-Modell.
interface ReactComponent<P> {
  props: P;
  render(): unknown;
}

// Construct Signature: nimmt Props im Konstruktor, erzeugt Component.
type ComponentClass<P> = new (props: P) => ReactComponent<P>;

// HOC: hebt Props an, gibt eine neue Component-Klasse zurück.
function withLogging<P>(WrappedClass: ComponentClass<P>): ComponentClass<P> {
  // Neue Klasse, die die übergebene Klasse umhüllt.
  return class extends (WrappedClass as any) {
    constructor(props: P) {
      super(props);
      console.log("Mounted:", WrappedClass.name);
    }
  } as ComponentClass<P>;
}

class Button implements ReactComponent<{ label: string }> {
  constructor(public props: { label: string }) {}
  render() { return `<button>${this.props.label}</button>`; }
}

const LoggedButton = withLogging(Button);
const instance = new LoggedButton({ label: "Klick" });
// Console: "Mounted: Button"
instance.render();

class Logger {
  static defaultLevel = "info";
  constructor(public name: string) {}
  log(msg: string) { console.log(`[${this.name}] ${msg}`); }
}

// Variante A — explizite Construct Signature: nur Konstruktor erfasst.
type LoggerCtorA = new (name: string) => Logger;

// Variante B — `typeof Logger`: Konstruktor PLUS statische Member.
type LoggerCtorB = typeof Logger;

function makeA(C: LoggerCtorA) {
  return new C("a");
  // C.defaultLevel  // Fehler — Construct Signature kennt keine Statics.
}

function makeB(C: LoggerCtorB) {
  const l = new C("b");
  console.log(C.defaultLevel);   // OK — `typeof` liefert auch Statics.
  return l;
}

// 1) `abstract` Klassen passen NICHT auf eine normale Construct Signature.
abstract class Shape { abstract area(): number; }

type ShapeCtor = new () => Shape;
// const c: ShapeCtor = Shape;
//                      ^^^^^ Fehler: abstrakte Klasse ist nicht newable.

// Lösung: `abstract new (...)`-Signatur seit TypeScript 4.2:
type AbstractShapeCtor = abstract new () => Shape;
const ac: AbstractShapeCtor = Shape;        // OK

// 2) Call Signature OHNE `new` matched KEINE Klassen.
type Factory = (n: string) => Date;
class MyDate {}
// const f: Factory = MyDate;
//                    ^^^^^^ Fehler — Klasse ist nur `new`-fähig.

// 3) Reiner Funktions-Typ kann KEINE Properties tragen.
type Fn = (n: number) => number;
const fn: Fn = (n) => n * 2;
// fn.label = "x";   // Fehler — Property auf Fn nicht zulässig.
//                   // Lösung: Interface mit Call Signature + Property.