Simple Typescript performance functions

// Define this in the build process in a Makefile maybe.
// It must be defined. It is the only way to do conditional
// compilation that I know of that is clean. The one issue
// is that you can't wrap it with other helper functions,
// or else we don't get dead-code elimination, because at
// compile time all evaluation involving the constant
// is replaced with booleans. Eg:
// `process.env.NODE_ENV !== "production"` becomes `true`,
// which drops the dead branch off of if-statements. Or at
// least it works this way with `esbuild`.
//
// The reason we want to drop it is because each timer fn
// invocation is not free, and in production if you're calling
// them alot, they add up. Useful for debugging, developing,
// but less useful in production.
declare const process: { env: { NODE_ENV: string } };

type DescriptorWrapper = (
    target: unknown,
    propKey: string,
    descriptor?: PropertyDescriptor
) => PropertyDescriptor;

type NamedDescriptorWrapper = (name?: string) => DescriptorWrapper;

export type Timed<T> = (name: string, f: (...args: unknown[]) => T)
    => (...args: unknown[]) => T;

// Decorator/annotation for method to time how long it takes to run.
let Time: NamedDescriptorWrapper;

let interiorTimer: Timed<unknown>;

if (process.env.NODE_ENV === "production") {
  Time =
      (_?: string) => (
          target: unknown,
          propKey: string,
          descriptor?: PropertyDescriptor,
      ) =>
          descriptor || Object.getOwnPropertyDescriptor(target, propKey);
  interiorTimer =
      <T>(name: string, f: (...args: unknown[]) => T) =>
          (...args) =>
              f(...args);
} else {
  Time = (name?: string) => {
    return (
        target: unknown,
        propKey: string,
        descriptor?: PropertyDescriptor,
    ) => {
      descriptor = descriptor || Object.getOwnPropertyDescriptor(
          target,
          propKey
      );
      const originalMethod = descriptor.value;
      descriptor.value = function (...args: unknown[]) {
        const prefix = (name ? name + "." : "") + propKey;
        const key = performance.now();
        const start = performance.mark(prefix + "-start-" + key);
        const result = originalMethod.apply(this, args);
        const end = performance.mark(prefix + "-end-" + key);
        performance.measure(prefix + "-" + key, start.name, end.name);
        return result;
      };
      return descriptor;
    };
  };
  interiorTimer = <T>(name: string, f: (...args: unknown[]) => T) =>
      (...args) => {
        const key = performance.now().toString();
        const start = performance.mark(name + "-start-" + key);
        const result = f(...args);
        const end = performance.mark(name + `-end-` + key);
        performance.measure(name + "-" + key, start.name, end.name);
        return result;
      };
}

// Wrap a function `f` as timed. Does NOT execute function though.
function timed<T>(name: string, f: (...args: unknown[]) => T):
    (...args: unknown[]) => T {
  return interiorTimer(name, f) as (...args: unknown[]) => T;
}

// Time one function that returns T.
function time<T>(name: string, f: (...args: unknown[]) => T): T {
  return (interiorTimer(name, f) as (...args: unknown[]) => T)();
}

export {TimePerformance, timed, time};

class Thing {
  @Time("Thing")
  longRunningProcess() {
    // ...do big computation
  }

  another: () => void = timed("Thing.another", () => {
    // ...do another computation
  });

  plainFn() {
    time("interior", () => {
      // ...do big computation
    });
  }
}