@bikky/compiler 0.0.3 → 0.0.4

package/Libraries/GlobalTypes.d.ts

@@ -1,43 +1,45 @@
 
-type Writable<T> = { -readonly [P in keyof T]: T[P] }
+declare module BikkyTypes {
 
-type GetConstraints<Extras> = Extras extends (Function & { prototype: infer Constraints })[] ? Constraints : never;
-type UnionToIntersection<U> =
-	(U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
-type AllConstraints<Super, Constraints> = UnionToIntersection<Constraints> extends never ? Super : Super & UnionToIntersection<Constraints>;
+	type Writable<T> = { -readonly [P in keyof T]: T[P] }
 
-type Class<T> = (new (...args: any[]) => T);
-type AbstractClass<T> = Function & { prototype: T };
-type ClassObject<T> = T extends (new (...args: any[]) => infer C) ? C : never;
-type AbstractClassObject<T> = T extends (Function & { prototype: infer C }) ? C : never;
-type AbstractClassArguments<T> = T extends abstract new (...args: infer A) => any ? A : never;
-type ClassArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
+	type GetConstraints<Extras> = Extras extends (Function & { prototype: infer Constraints })[] ? Constraints : never;
+	type UnionToIntersection<U> =
+		(U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never
+	type AllConstraints<Super, Constraints> = UnionToIntersection<Constraints> extends never ? Super : Super & UnionToIntersection<Constraints>;
 
-type ConstructArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
-type Prototype<T> = (Function & { prototype: T });
-type ObjectType<T> = T extends (new (...args: any[]) => infer C) ? C : never;
+	type Class<T> = (new (...args: any[]) => T);
+	type AbstractClass<T> = Function & { prototype: T };
+	type ClassObject<T> = T extends (new (...args: any[]) => infer C) ? C : never;
+	type AbstractClassObject<T> = T extends (Function & { prototype: infer C }) ? C : never;
+	type AbstractClassArguments<T> = T extends abstract new (...args: infer A) => any ? A : never;
+	type ClassArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
 
+	type ConstructArguments<T> = T extends (new (...args: infer C) => any) ? C : never;
+	type Prototype<T> = (Function & { prototype: T });
+	type ObjectType<T> = T extends (new (...args: any[]) => infer C) ? C : never;
+}
 //Unfortunately Typescript doesn't currently support the following typing (as in the decorator's typing
 // information will not properly alter typescript's typing information):
 //First set of params are the ones supplied in the decorator, like: @mixin(common, extra1, extra2);
 declare function mixin<
 	Super extends Object,
-	Extras extends Prototype<any>[]
->(common: Prototype<Super>, ...constraints: Extras): (
+	Extras extends BikkyTypes.Prototype<any>[]
+>(common: BikkyTypes.Prototype<Super>, ...constraints: Extras): (
 		//Second set of params are the class the decorator is decorating, in this case the mixin.
 		<
 			MixinClass extends Function & { prototype: Object },
-			Mixin extends Prototype<MixinClass>,
-			ConstructorArgs extends ConstructArguments<Mixin>,
+			Mixin extends BikkyTypes.Prototype<MixinClass>,
+			ConstructorArgs extends BikkyTypes.ConstructArguments<Mixin>,
 		>
 			(mixin: MixinClass) => MixinClass & {
 				//We return a mix function that takes the class that the mixin
 				// is to be mixed onto. We want to ensure that the new class
 				// fulfills all the requirements listed with the decorator.
 				mix: <
-					Core extends AllConstraints<Super, GetConstraints<Extras>>
+					Core extends BikkyTypes.AllConstraints<Super, BikkyTypes.GetConstraints<Extras>>
 					>
-					(core: Prototype<Core>) =>
+					(core: BikkyTypes.Prototype<Core>) =>
 					//Lastly we return a function that requires the mixin's constructor arguments and returns 
 					// an object which is a combination of the mixin and the provided core class.
 					(new (...args: ConstructorArgs) => Core & Mixin);
@@ -48,10 +50,10 @@ declare function mixin<
 // decorators are updated.
 declare function makeMixer<
 	MixinClass extends (new (...args: any[]) => object),
-	Mixin extends ClassObject<MixinClass>,
-	ConstructorArgs extends ConstructArguments<MixinClass>,
-	Super extends Object, Extras extends Prototype<any>[]>
-	(mixin: MixinClass, common: Prototype<Super>, ...constraints: Extras): (
-		<Core extends AllConstraints<Super, GetConstraints<Extras>>>(core: { new(...args: any[]): Core } ) =>
+	Mixin extends BikkyTypes.ClassObject<MixinClass>,
+	ConstructorArgs extends BikkyTypes.ConstructArguments<MixinClass>,
+	Super extends Object, Extras extends BikkyTypes.Prototype<any>[]>
+	(mixin: MixinClass, common: BikkyTypes.Prototype<Super>, ...constraints: Extras): (
+		<Core extends BikkyTypes.AllConstraints<Super, BikkyTypes.GetConstraints<Extras>>>(core: { new(...args: any[]): Core } ) =>
 			(new (...args: ConstructorArgs) => Core & Mixin));
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@bikky/compiler",
-    "version": "0.0.3",
+    "version": "0.0.4",
     "description": "Typescript modified for compiling space squad",
     "main": "./Libraries/BiscuitLibraries.js",
     "author": {