We Keep Coding

Javascript - How to access class methods within a return function

I've been stuck on this issue for a while. I cannot describe it accurately enough to find solutions online - apologies if it is a duplicate question.
I want to access helloWorld() from module.js:
export function HelperProvider() {
return class Helper {
constructor() {
}
helloWorld() {
console.log('Hello World');
}
}
}
In another file:
import { HelperProvider } from 'module.js'
const helperProvider = HelperProvider;
const helper = new helperProvider();
helper.helloWorld();
However, I encounter the following error:
Uncaught TypeError: helper.helloWorld is not a function
Any help would be very much appreciated.

You need to invoke the function HelperProvider to get the class.
const helperProvider = HelperProvider();
function HelperProvider() {
return class Helper {
constructor() {
}
helloWorld() {
console.log('Hello World');
}
}
}
const helperProvider = HelperProvider();
const helper = new helperProvider();
helper.helloWorld();

You are using module features that's not out of the box in nodejs, if you want to use modules you'll need to set type: "module" in the package.json file... see details
If you wanna use node ways:
module.js
function HelperProvider() {
return class Helper {
constructor() {}
helloWorld() {
console.log("Hello World");
}
};
}
module.exports = HelperProvider;
index.js
const HelperProvider = require("./Helper");
const helperProvider = HelperProvider();
const helper = new helperProvider();
helper.helloWorld();

Different way of work with module require() parameters?

If you want pass parameters into module you do it like this:
index.js
let test = require("./module.js")(something);
module.js
module.exports = (something) => {
//Working with `something` here
};
But is there so way how to do it without using module.exports = (var) => {}?
More specifficaly to be able to write for example code outside function container and then at the end of file do module.exports?
Or you are able to just do this?
const globalSomething;
(something) => {
globalSomething = something;
}
module.exports = heavyWorkWith(globalSomething);
If you understand me.

You aren't restricted to an unnamed function to pass around parameters, you can use a named function
export default function myExport(something) {
//...
}
or even a class
export default class myExport() {
constructor(something) {
//...
}
}
And on the inverse side, import:
const myExport = require('./myModuleOrWhatever');
const foo = new myExport(something);
Even moreso, you can just pass along module constants with your anonymous module export
const bar = somethingElse;
const baz = moreElse;
/*
alernatively
export default const bar = somethingElse
*/
module.exports = {
foo: (something) => {
//Working with `something` here
},
bar,
baz,
};

How to export functions in modules?

Dear all I just started learning modules in javascript. This is my implementation of a module:
module.exports = function(logger_level) {
this.info = function(message) {
stdout(message);
};
};
function stdout(message)
{
process.stdout.write(message+'\n');
}
and I have to invoke it like this:
var logger = require('./js/logger.js');
var logger1 = new logger("info1");
logger1.info("info");
My question is how to change my implementation of the module so that I could invoke it like this:
var logger = require('./js/logger.js')("info");
logger.info("info");

If you want to use it like that, there's no need for a constructor function at all:
module.exports = {
info: function(message) {
stdout(message);
}
};
function stdout(message)
{
process.stdout.write(message+'\n');
}
I just started learning modules in javascript.
Note that this isn't "modules in JavaScript" so much as it is "modules in NodeJS". JavaScript's modules, which weren't introduced until ES2015 ("ES6"), look and act quite different, but they aren't broadly-supported yet. When they are, your module might look like this:
// ES2015+ syntax
export default {
info: function(message) {
stdout(message);
}
};
function stdout(message)
{
process.stdout.write(message+'\n');
}
...and used like this:
import logger from './logger.js';
logger.info("info");

You're looking for a factory function. Applying it to your use case it would look like:
module.exports = function(logger_level) {
return {
info: function(message) {
stdout(message);
}
};
};
function stdout(message)
{
process.stdout.write(message+'\n');
}

You can wrap your constructor function with an object and return an instance of your constructor function
module.exports = {
return new function(logger_level) {
this.info = function(message) {
stdout(message);
};
};
}
And call it
var logger = require('./js/logger.js');
logger.info("info");
You can also make a singleton pattern to work with a single instance of your constructor function

Set public variables node.js

I need to access to a variable that i define in my index.js from static.js which is called with require()
Index.js
function API() {
var self = this
self.init = function(apikey, region, locale) {
//Some stuff
self.region = region
self.locale = locale
self.apikey = apikey
self.static = require('./static').static
}
}
module.exports = new API();
Static.js
module.exports = {
static: {
someFunction: function(someParameters) {
//Need to access to self.region, self.locale and self.apikey
},
otherFunction: function(someParameters) {
//Need to access to self.region, self.locale and self.apikey
}
}
My problem is to use region, locale and apikey from the static.js file
Test.js
var api = require('./index.js');
api.init('myKey', 'euw', 'en_US')
console.log(api);
does that:
RiotAPI {
region: 'euw',
locale: 'en_US',
apikey: 'myKey',
static: { someFunction: [Function], otherFunction: [Function] }
}
which is okay but when i call someFunction() with the good arguments it tells me that self.region (and the others i guess) is not defined

You need to put the methods from static.js at the top-level of your API instance.
var static = require('./static').static
function API() {
// constructor
}
API.prototype.init = function(apikey, region, locale) {
//Some stuff
this.region = region
this.locale = locale
this.apikey = apiKey
}
Object.assign(API.prototype, static)
module.exports = new API();
Then reference this.region etc. in your static methods.

Convert Namespaced Javascript Functions to Typescript

I know that all javascript is valid typescript but I'd like to start converting my javascript to typescript conventions. I'm battling this one snippet of JS:
My standard Javascript that works
if (MyCompany === undefined) {
var MyCompany = {};
}
MyCompany.Uploader = MyCompany.Uploader || {};
MyCompany.Uploader.Core = function (config) {
'use strict';
function build() {
console.log("building");
}
return {
build: build
};
};
var config = {this: "that};
MyCompany.Uploader.Core(config).build(); // outputs building to console
I've been messing with multiple approaches and I feel like I not close enough.
My failed attempt at converting to Typescript
namespace MyCompany.Uploader {
export var Core = (config:any) => {
function build() {
console.log("building");
}
};
}
let configobj = {here:"there"};
MyCompany.Uploader.Core(configobj).build();
This simply doesn't work. I can't seem to access the build function. I'm sure this is a rookie mistake.
The error I get: Property build does not exist on type void

That's because you did not add an important part of your javascript code into the typescript version, and that's the return object which contains the reference for the build function, it should be:
namespace MyCompany.Uploader {
export var Core = (config: any) {
function build() {
console.log("building");
}
return {
build: build
}
};
}
let configobj = { here: "there" };
MyCompany.Uploader.Core(configobj).build();
You can also define interfaces for the config and the return object:
namespace MyCompany.Uploader {
export interface Config {
here: string;
}
export interface Builder {
build: () => void;
}
export var Core = (config: Config): Builder => {
function build() {
console.log(config.here);
}
return {
build: build
}
};
}
let configobj = { here: "there" };
MyCompany.Uploader.Core(configobj).build();