Just as a quick example, it could be something like this... it's just a lot of code to be throwing in the transpiled version

declare global {
	interface Function {
		__getSymbol(): symbol;
		getType(): Type;
	}
	interface Object {
		__getSymbol(): symbol;
		getType(): Type;
	}
}

export class SomeClass {
	someMethod() {
		return "";
	}
}


Object.defineProperty(SomeClass, '__getSymbol', {
	enumerable : false,
	get(): any {
		return function () {
			return Symbol.for("485");
		}
	}
});
Object.defineProperty(SomeClass, 'getType', {
	enumerable : false,
	get(): any {
		return function () {
			return Type._getTypeMeta(Number(this.__getSymbol().description))
		}
	}
});

(this actually works with the id for the type :D)

On another side-note, are you able to share your editor formatting config? I was playing a little earlier and my autoformatting completely changes the structure, which I obviously don't want to be doing on your project 😅

My formatting is affected by the C# formatting,.. .NET devs friendly, JavaScript devs unfriendly. 😅
I've just pushed updated .editorconfig but it is supported only by Jetbrains products (Webstorm, Rider etc.)
ESLint is on the TODO list. Same as Github Actions cuz of PRs..

That's totally fine with me, I like the style of it. and perfect, I was hoping it was JetBrains based :D

I will do some experimenting with my idea above, it seems there may be some flaws, jut realised that maybe I've mis-understood how javascript prototype works over all of the years 😅

There will be problem with Methods and similar things.. All of that can be used as Type. (I've implemented some of those things today :D)

module mod {}

class A {
  doSomething();
}

let x: A["doSomething"] = function() {};

let m: typeof mod = {};

You want to generate those defineProperty, right? And make it available for everything? It means generate those defineProperty for every type in the source code; even those inside 3rd party packages...
Current implementation generate type information just for types passed to getType(). Generating type information for everything is so OP for projects with thousands of dependencies.. 😮

BTW: What is your usage? SomeClass.getType()? Well, the C#'s usage is var x = new SomeClass(); x.GetType();. It should be called on the instance of an Object.

So it would be:

Object.defineProperty(Object.prototype, 'getType', {
	enumerable : false,
	get(): any {
		return function () {
			return Type._getTypeMeta(Number(this.__getSymbol().description))
		}
	}
});

And generate only those __getSymbol().

IMHO, it will be much easier to handle all .getType() method calls an process that the same way as getType<T>() function calls.

And just add global declaration into the tst-reflect package:

global.d.ts

interface Object
{
	getType: (() => import("tst-reflect").Type) & { __tst_reflect__: true }; // that object with __tst_reflect__ is for identification of our `.getType()`, cuz somebody can override that with own method.
}

and

reflect.ts

Object.defineProperty(Object.prototype, "getType", {
	enumerable: false,
	get(): any
	{
		return function () {
			return undefined;
		};
	}
});

And final usage:

class A {}

const a = new A();

a.getType(); // handled by transformer and replaced by tst_reflect.getType(12345)

PS: Maybe I just missed your point,.. write me some example, what to change in runtime, transformer and what will be the usage.

I've read somewhere here on the repo, there's no "global" store for the type data it's essentially just what is picked up on the fly and replaced in file?

Yes and no.

Base(/first implemented) mode is per-file "cache". Each type's info is generated once per file, no matter how many getType calls are there. Because in TS you don't know which file is "root" (executed/loaded first), so you don't know where to place all the generated metadata.

Example of the base per-file mode:

tsconfig.json

	"reflection": {
		"metadata": false, // disable second "metadata" mode, which is under development but it is default mode now, cuz it is better
		"debugMode": false
	}

index.ts

import {
	getType,
	Type,
	TypeKind
} from "tst-reflect";

abstract class Animal
{
	abstract get kind(): string;
	abstract get name(): string;

	protected constructor(protected readonly _kind: string)
	{
	}

	abstract makeSound();
}

const typeOfAnimal: Type = getType<Animal>();

console.log("Kind of the Type: ", TypeKind[typeOfAnimal.kind], " Name of the Type:", typeOfAnimal.name, " Full name of the Type:", typeOfAnimal.fullName, " Details:", typeOfAnimal);

console.log(getType<Animal>().name);
console.log(getType<Animal>().fullName);
console.log(getType<Animal>().baseType);

Generated JS:

index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tst_reflect_1 = require("tst-reflect");
tst_reflect_1.getType({ n: "Animal", fn: "..\\index.ts:Animal", props: [{ n: "kind", t: tst_reflect_1.getType({ n: "string", k: 2 }) }, { n: "name", t: tst_reflect_1.getType({ n: "string", k: 2 }) }, { n: "_kind", t: tst_reflect_1.getType({ n: "string", k: 2 }) }], ctors: [{ params: [{ n: "_kind", t: tst_reflect_1.getType({ n: "string", k: 2 }) }] }], k: 1, ctor: () => Animal }, 23251);
class Animal {
    constructor(_kind) {
        this._kind = _kind;
    }
}
const typeOfAnimal = tst_reflect_1.getType(23251);
console.log("Kind of the Type: ", tst_reflect_1.TypeKind[typeOfAnimal.kind], " Name of the Type:", typeOfAnimal.name, " Full name of the Type:", typeOfAnimal.fullName, " Details:", typeOfAnimal);
console.log(tst_reflect_1.getType(23251).name);
console.log(tst_reflect_1.getType(23251).fullName);
console.log(tst_reflect_1.getType(23251).baseType);
//# sourceMappingURL=index.js.map

Transformer goes through source code and looks for getType<T>() calls. If there is an getType call, it generates object with type details, puts it at the top of current file and replaces that getType<T>()call by runtime call of getType(id) with type's id as argument.
Each call for same type is replaced by the same getType(id) call.

Second "metadata" mode (work in progress, buggy)

Enabled by default as I wrote in first section.
That mode generates all the types' metadata into one metadata file which must be imported by user/programmer in root module.
All the types are in that metadata library, but only those requested by getType<T>() calls.

I wanted to implement config option to enable "full" metadata library, it means generate metadata for all of the types in the project (including packages) but cuz of performance, it is not a good idea..

Okay I see now, I think I tried the second option at some point, which didn't work for me, but now I think back... I don't think I imported the generated file 😅

I wanted to implement config option to enable "full" metadata library, it means generate metadata for all of the types in the project (including packages) but cuz of performance, it is not a good idea..

Yeah... I can see that, it might be a good idea to be able to configure some paths which will be generated for, regardless of it, kind of like typescripts tsconfig "include" option

If for example, with your container, you made a package, but had some logic depending on reflection there, it would cause some problems and not work, or in a mono-repo style project

I'd be open to put some more work into this metafile style generator once I'm done with method reflection :)

The biggest issue in metadata lib mode are imports of classes for ctor. Check https://github.com/Hookyns/ts-reflection/blob/c2242921fec1d226f8a3482a8112612be10e9bff/transformer/src/getTypeDescription.ts#L299
Excluding this main issue, it should work quite well.