Behavior can JS-reparent itself.

Only 'instanceof' functionality.

No JS method overriding yet.
No supercalls of JS superclass yet.

lang/API-CHANGES.txt

@@ -3,8 +3,11 @@
 * Deprecate Behavior >> javascriptConstructor(:)
 
 + Behavior >>
+  + beJavaScriptSubclassOf:
   + javaScriptConstructor
   + javaScriptConstructor:
++ ClassBuilder >>
+  + javaScriptSubclassOf:
 
 
 0.23.2:

lang/src/Kernel-Classes.js

@@ -246,6 +246,30 @@ return self;
 }; }),
 $globals.Behavior);
 
+$core.addMethod(
+$core.method({
+selector: "beJavaScriptSubclassOf:",
+protocol: "accessing",
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["aJavaScriptFunction"],
+source: "beJavaScriptSubclassOf: aJavaScriptFunction\x0a\x09\x22Set the JS constructor to subclass of aJavaScriptFunction.\x0a\x09That way I stay part of (simulated) Smalltalk hierarchy,\x0a\x09but my instances will physically be instanceof aJavaScriptFunction.\x22\x0a\x09\x0a\x09self javaScriptConstructor:\x0a\x09\x09(ClassBuilder new javaScriptSubclassOf: aJavaScriptFunction)",
+referencedClasses: ["ClassBuilder"],
+//>>excludeEnd("ide");
+pragmas: [],
+messageSends: ["javaScriptConstructor:", "javaScriptSubclassOf:", "new"]
+}, function ($methodClass){ return function (aJavaScriptFunction){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+$self._javaScriptConstructor_($recv($recv($globals.ClassBuilder)._new())._javaScriptSubclassOf_(aJavaScriptFunction));
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"beJavaScriptSubclassOf:",{aJavaScriptFunction:aJavaScriptFunction})});
+//>>excludeEnd("ctx");
+}; }),
+$globals.Behavior);
+
 $core.addMethod(
 $core.method({
 selector: "canUnderstand:",
@@ -1734,6 +1758,33 @@ return self;
 }; }),
 $globals.ClassBuilder);
 
+$core.addMethod(
+$core.method({
+selector: "javaScriptSubclassOf:",
+protocol: "class definition",
+//>>excludeStart("ide", pragmas.excludeIdeData);
+args: ["javaScriptClass"],
+source: "javaScriptSubclassOf: javaScriptClass\x0a\x09<inlineJS: '\x0a\x09\x09var subclass = function () {};\x0a\x09\x09subclass.prototype = Object.create(javaScriptClass.prototype);\x0a\x09\x09return subclass;'>",
+referencedClasses: [],
+//>>excludeEnd("ide");
+pragmas: [["inlineJS:", ["\x0a\x09\x09var subclass = function () {};\x0a\x09\x09subclass.prototype = Object.create(javaScriptClass.prototype);\x0a\x09\x09return subclass;"]]],
+messageSends: []
+}, function ($methodClass){ return function (javaScriptClass){
+var self=this,$self=this;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+return $core.withContext(function($ctx1) {
+//>>excludeEnd("ctx");
+
+		var subclass = function () {};
+		subclass.prototype = Object.create(javaScriptClass.prototype);
+		return subclass;;
+return self;
+//>>excludeStart("ctx", pragmas.excludeDebugContexts);
+}, function($ctx1) {$ctx1.fill(self,"javaScriptSubclassOf:",{javaScriptClass:javaScriptClass})});
+//>>excludeEnd("ctx");
+}; }),
+$globals.ClassBuilder);
+
 $core.addMethod(
 $core.method({
 selector: "migrateClass:superclass:",

lang/src/Kernel-Classes.st

@@ -52,6 +52,15 @@ basicOrganization: aClassOrganizer
 	organization := aClassOrganizer
 !
 
+beJavaScriptSubclassOf: aJavaScriptFunction
+	"Set the JS constructor to subclass of aJavaScriptFunction.
+	That way I stay part of (simulated) Smalltalk hierarchy,
+	but my instances will physically be instanceof aJavaScriptFunction."
+	
+	self javaScriptConstructor:
+		(ClassBuilder new javaScriptSubclassOf: aJavaScriptFunction)
+!
+
 instanceVariableNames
 	^ slots
 !
@@ -365,6 +374,13 @@ class: aClass slots: aCollection
 			yourself)
 !
 
+javaScriptSubclassOf: javaScriptClass
+	<inlineJS: '
+		var subclass = function () {};
+		subclass.prototype = Object.create(javaScriptClass.prototype);
+		return subclass;'>
+!
+
 superclass: aClass subclass: className
 	^ self superclass: aClass subclass: className slots: #() package: nil
 !