@makano/rew 1.4.5 → 1.4.7

package/lib/rew/functions/types.js

@@ -41,7 +41,7 @@ function typedef(value, strict = false) {
 	});
 }
 
-function typef(fn, returnType) {
+function typef(fn, returnType, argumentsTypes) {
 	if(typeof returnType == "function"){
 		const ref = fn;
 		fn = returnType;
@@ -51,7 +51,17 @@ function typef(fn, returnType) {
 		throw new Error('First argument must be a function');
 	}
 	if (typeof returnType == 'function' && returnType.type instanceof Type) returnType = returnType.type;
+	const requiredArguments = Array.isArray(argumentsTypes) ? argumentsTypes.filter(i => Array.isArray(i) ? !i.includes(null) : true) : [];
 	const wrappedFn = function(...args){
+		if(argumentsTypes && Array.isArray(argumentsTypes)){
+			if(args.length !== requiredArguments.length && args.length !== argumentsTypes.length){
+				throw new TypeError(`Function ${fn.name || '<anonymous>'} takes exactly ${requiredArguments.length} parameters`)
+			}	
+			const argumentsTyped = typeAre(args, argumentsTypes);
+			if(argumentsTyped !== false){
+				throw new TypeError(`Function ${fn.name || '<anonymous>'} call error: Parameter at index ${argumentsTyped} is of the wrong type`);
+			}
+		}
 		const result = fn.call(this, ...args);
 		if(!typeis(result, wrappedFn.returnType)){
 			throw new TypeError(`Function ${fn.name || '<anonymous>'} does not return it's own return type.`);
@@ -60,13 +70,32 @@ function typef(fn, returnType) {
 	}
 	wrappedFn.returnType = returnType;
 	wrappedFn.type = returnType;
+	wrappedFn.argumentsTypes = argumentsTypes;
 	return wrappedFn;
 }
-typef.is = function(func, returnType){
+typef.is = function(func, returnType, argumentsTypes){
 	return typeis(func.returnType.defaultValue, returnType);
 }
 
+const typeAre = (values, types) => {
+	const verified = values.map((t, i) => Array.isArray(types[i]) ? (types[i].map((t2) => typeis(t, t2)).includes(true)) : typeis(t, types[i]));
+	const hasWrong = verified.indexOf(false);
+	return hasWrong > -1 ? hasWrong : false;
+}
+
 function typeis(obj, typeDef, missingObjects = false) {
+
+	if(obj == null && typeDef === null) return true;
+	else if(obj == null) return false;
+	if(obj == undefined && typeDef === undefined) return true;
+	else if(obj == undefined) return false;
+
+	if(typeDef == null && obj === null) return true;
+	else if(typeDef == null) return false;
+
+	if(typeDef == undefined && obj === undefined) return true;
+	else if(typeDef == undefined) return false;
+
 	// Resolve Type
 	if (typeof typeDef == 'function' && typeDef.type instanceof Type) typeDef = typeDef.type;
 
@@ -123,6 +152,7 @@ function typeis(obj, typeDef, missingObjects = false) {
 
 	return missingObjects ? [true] : true;
 }
+typeis.multi = (values, types) => typeAre(values, types);
 
 function typex(child, parent) {
 	return child.prototype instanceof parent || child === parent;

package/lib/rew/modules/context.js

@@ -63,10 +63,6 @@ module.exports.prepareContext = function (
       ...custom_context,
       Usage
     };
-    globalEmitter.on('attach_name', (name, object) => {
-      context[name] = object;
-    });
-    globalEmitter.on('detach_name', (name) => delete context[name]);
     std.prototype = { ns: (cb) => {
       return new (class extends STDNS {
         constructor(){
@@ -143,6 +139,10 @@ module.exports.prepareContext = function (
     })
     context.std = std;
   }
+  globalEmitter.on('attach_name', (name, object) => {
+    context[name] = object;
+  });
+  globalEmitter.on('detach_name', (name) => delete context[name]);
   if (!context.process)
     context.process = {
       argv: options.argv || process.argv,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "A simple coffescript runtime and app manager",
   "main": "main.js",
   "directories": {