typescript: call signatures example question

I am learning about typescript call signatures and need the help of a typescript expert:

The following code compiles, but running it in 'typescript playground' results in a runtime error.
The runtime error is: ([ERR]: logFunc is not a function)

    type LogFunctionWithPrefixCB = {
logPrefix: string;
(stringToLog: string) : void; // that's the shortcut - supposedly type  LogFunctionWithPrefixCB is callable (can call it as a function)
}
function makeLogFunctionWithPrefixCB( prefixStr : string) : LogFunctionWithPrefixCB {
let loggerFunc = function(this : LogFunctionWithPrefixCB, stringToLog: string) {
console.log(`${this.logPrefix}: ${stringToLog}`);
};
let ret = {
logPrefix: prefixStr,
call : loggerFunc
};
return ret as LogFunctionWithPrefixCB;
}
// using the
function doSomething(logFunc : LogFunctionWithPrefixCB) {
logFunc("hello world");    // no compilation error - but get runtime error "logFunc is not a function "
}
let logger = makeLogFunctionWithPrefixCB("prefix:");
doSomething(logger);

Now the next example does not compile, but it runs and gives the expected result: (see logfunc.call(...))
The typescript compilation error is: "Expected 2 arguments, but got 1."

Tried lots of typescript versions - all with the same result.

    type LogFunctionWithPrefixCB = { 
logPrefix: string;
(stringToLog: string) : void; // that's the shortcut - supposedly type  LogFunctionWithPrefixCB is callable (can call it as a function)
}
function makeLogFunctionWithPrefixCB( prefixStr : string) : LogFunctionWithPrefixCB {
let loggerFunc = function(this : LogFunctionWithPrefixCB, stringToLog: string) {
console.log(`${this.logPrefix}: ${stringToLog}`);
};
let ret = {
logPrefix: prefixStr,
call : loggerFunc
};
return ret as LogFunctionWithPrefixCB;
}
// using the 
function doSomething(logFunc : LogFunctionWithPrefixCB) {
logFunc.call("hello world");    // works, but typescript compilation error "Expected 2 arguments, but got 1 "
}
let logger = makeLogFunctionWithPrefixCB("prefix:");
doSomething(logger);

There are multiple ways to make a function that also has properties on it. The easiest way to do so is to create your function value as a const and then just add the properties afterward, which is explicitly supported in TypeScript. Something like:

const f = function(){ /*⋯*/ };
f.prop = 123;

That is the basic approach you can take. But:

Your function is of the form

const f = function(stringToLog) {
console.log(`${this.logPrefix}: ${stringToLog}`);
}
f.logPrefix = prefixStr;

but the only way that would work is if the this context on which the function is called happens to be the function itself. And this is very, very unlikely. If you just call it like f(""), then there's no this context at all (it would almost certainly be undefined). You'd have to bind it to itself before calling it, like f.bind(f)(""). And if you wanted this to happen automatically, then you'd need to define something like const g = f.bind(f). But now g is just a function without the extra logPrefix property. It's a mess, and much more complicated than necessary. Messing with this is probably not what you want.

Instead you can just refer to the function object directly where you were using this. That brings us to this implementation:

function makeLogFunctionWithPrefixCB(prefixStr: string): LogFunctionWithPrefixCB {
const loggerFunc = function (stringToLog: string) {
console.log(`${loggerFunc.logPrefix}: ${stringToLog}`);
};
loggerFunc.logPrefix = prefixStr;
return loggerFunc;
}

That compiles without error, and we can see how it works:

function doSomething(logFunc: LogFunctionWithPrefixCB) {
logFunc("hello world");
}
let logger = makeLogFunctionWithPrefixCB("prefix");
doSomething(logger); // "prefix: hello world" 
logger.logPrefix = "changedPrefix";
doSomething(logger); // "changedPrefix: hello world" 

Looks good. The logger object is of type LogFunctionWithPrefixCB and so it has a logPrefix property, and if we alter that property it alters the behavior of logger's function in the expected way.

Playground link to code