@croquet/worldcore-card - npm Package Compare versions

Comparing version 1.1.2 to 1.2.0

index.js

 
 export * from "./src/Card";
+export * from "./src/CardWidget";
 

package.json

 {
   "name": "@croquet/worldcore-card",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Card Component for Croquet Worldcore",
@@ -26,4 +26,4 @@ "keywords": [
   "dependencies": {
-    "@croquet/worldcore-kernel": "^1.1.2",
-    "@croquet/worldcore-three": "^1.1.2"
+    "@croquet/worldcore-kernel": "^1.2.0",
+    "@croquet/worldcore-three": "^1.2.0"
   },
@@ -33,3 +33,3 @@ "publishConfig": {
   },
-  "gitHead": "9a3b57dc464d01f1701d621210fbfb7e4bc601c0"
+  "gitHead": "7633b5da452e79cee2be15721d744e4cd9f9924c"
 }

src/Card.js

@@ -1,2 +0,2 @@
-import { Actor, Pawn, GetPawn, mix, RegisterMixin } from "@croquet/worldcore-kernel";
+import { Actor, Pawn, GetPawn, mix, RegisterMixin, AM_Predictive, PM_Predictive } from "@croquet/worldcore-kernel";
 
@@ -20,6 +20,8 @@ //------------------------------------------------------------------------------------------
         if (this.onPointerUp)this.listen("pointerUp", this._onPointerUp);
+        if (this.onKeyDown) this.listen("keyDown", this.onKeyDown);
+        if (this.onKeyUp) this.listen("keyUp", this.onKeyUp);
         this.future(0).dropoutTick();
     }
 
-    get isMultiuser() { return this._multiuser; }
+    get isMultiuser() { return this._multiuser || true; }
     get isHovered() { return this.hovered.size};
@@ -84,2 +86,4 @@ get isFocused() { return this.focused.size};
     // onPointerUp(pe) {}
+    // onKeyDown(e) {}
+    // onKeyUp(e) {}
 
@@ -99,11 +103,15 @@ }
         super(...args);
-        this.listen("pointerDown", this._onPointerDown);
-        this.listen("pointerUp", this._onPointerUp);
-        this.listen("pointerOver", this._onPointerOver);
-        this.listen("pointerMove", this._onPointerMove);
-        this.listen("pointerEnter", this._onPointerEnter);
-        this.listen("pointerLeave", this._onPointerLeave);
-        this.listen("focusSuccess", this._onFocusSuccess);
+        if (this.onPointerDown) this.listen("pointerDown", this.onPointerDown);
+        if (this.onPointerUp) this.listen("pointerUp", this.onPointerUp);
+        // if (this.onPointerOver) this.listen("pointerOver", this.onPointerOver);
+        if (this.onPointerMove) this.listen("pointerMove", this.onPointerMove);
+        if (this.onPointerEnter) this.listen("pointerEnter", this.onPointerEnter);
+        if (this.onPointerLeave) this.listen("pointerLeave", this.onPointerLeave);
+        if (this.onPointerWheel) this.listen("pointerWheel", this.onPointerWheel);
+        if (this.onPointerDoubleDown) this.listen("pointerDoubleDown", this.onPointerDoubleDown);
+        if (this.onFocus) this.listen("focusSuccess", this.onFocus);
+        if (this.onBlur) this.listen("blur", this.onBlur);
+        if (this.onKeyDown) this.listen("keyDown", this.onKeyDown);
+        if (this.onKeyUp) this.listen("keyUp", this.onKeyUp);
         this.listen("focusFailure", this._onFocusFailure);
-        this.listen("blur", this._onBlur);
     }
@@ -131,50 +139,22 @@
 
-    _onPointerDown(pe) {
-        this.onPointerDown(pe);
-    }
-
-    _onPointerUp(pe) {
-        this.onPointerUp(pe)
-    }
-
-    _onPointerMove(pe) {
-        this.onPointerMove(pe)
-    }
-
-    _onPointerOver(pe) {
-        this.onPointerOver(pe)
-    }
-
-    _onPointerEnter(pointerId) {
-        this.onPointerEnter(pointerId)
-    }
-
-    _onPointerLeave(pointerId) {
-        this.onPointerLeave(pointerId)
-    }
-
-    _onFocusSuccess(pointerId) {
-        this.onFocus(pointerId)
-    }
-
     _onFocusFailure(pointerId) {
         const pointerPawn = GetPawn(pointerId);
         if (pointerPawn) pointerPawn.focusPawn = null;
-        this.onFocusFailure(pointerId)
+        if (this.onFocusFailure) this.onFocusFailure(pointerId)
     }
 
-    _onBlur(pointerId) {
-        this.onBlur(pointerId)
-    }
+    // onPointerEnter(pointerId) {}
+    // onPointerLeave(pointerId) {}
+    // onFocus(pointerId) {}
+    // onFocusFailure(pointerId) {}
+    // onBlur(pointerId) {}
 
-    onPointerEnter(pointerId) {}
-    onPointerLeave(pointerId) {}
-    onFocus(pointerId) {}
-    onFocusFailure(pointerId) {}
-    onBlur(pointerId) {}
+    // onPointerDown(pe) {}
+    // onPointerUp(pe) {}
+    // onPointerMove(pe) {}
+    // onPointerWheel(e) {}
+    // onPointerDoubleDown(pe) {}
+    // onKeyDown(e) {}
+    // onKeyUp(e) {}
 
-    onPointerDown(pe) {}
-    onPointerUp(pe) {}
-    onPointerMove(pe) {}
-
 }
@@ -204,2 +184,4 @@
                 this.subscribe("ui", "pointerMove", this.doPointerMove);
+                this.subscribe("ui", "wheel", this.doPointerWheel);
+                this.subscribe("ui", "doubleDown", this.doPointerDoubleDown);
             }
@@ -210,3 +192,8 @@ else {
                 this.subscribe("input", "pointerMove", this.doPointerMove);
+                this.subscribe("input", "wheel", this.doPointerWheel);
+                this.subscribe("input", "doubleDown", this.doPointerDoubleDown);
             }
+
+            this.subscribe("input", "keyDown", this.doKeyDown);
+            this.subscribe("input", "keyUp", this.doKeyUp);
         }
@@ -233,2 +220,3 @@ }
         if (e.button === 0) {
+            this.isPointerDown = true;
             if (this.focusPawn !== rc.pawn) {
@@ -252,2 +240,4 @@ if (this.focusPawn) this.focusPawn.say("blur", this.actor.id);
         if (this.focusPawn) this.focusPawn.say("pointerUp", this.pointerEvent(rc));
+        this.isPointerDown = false;
+        // this.focusPawn = null;
     };
@@ -266,5 +256,27 @@
 
-        if (this.focusPawn) this.focusPawn.say("pointerMove", this.pointerEvent(rc));
+        if (this.isPointerDown && this.focusPawn) this.focusPawn.say("pointerMove", this.pointerEvent(rc));
     }
 
+    doPointerWheel(e) {
+        if (this.focusPawn) this.focusPawn.say("pointerWheel", e);
+    }
+
+    doPointerDoubleDown(e) {
+        this.focusTimeout = this.now();
+        const x = ( e.xy[0] / window.innerWidth ) * 2 - 1;
+        const y = - ( e.xy[1] / window.innerHeight ) * 2 + 1;
+        const rc = this.pointerRaycast([x,y]);
+        if (this.focusPawn) this.focusPawn.say("pointerDoubleDown", this.pointerEvent(rc));
+    }
+
+    doKeyDown(e) {
+        this.focusTime = this.now();
+        if (this.focusPawn) this.focusPawn.say("keyDown", e);
+    }
+
+    doKeyUp(e) {
+        this.focusTime = this.now();
+        if (this.focusPawn) this.focusPawn.say("keyUp", e);
+    }
+
     pointerEvent(rc) {
@@ -275,3 +287,3 @@ const pe = {pointerId: this.actor.id}
             pe.xyz = rc.xyz,
-            pe.xyzLocal = rc.xyzLocal,
+            pe.uv = rc.uv;
             pe.normal = rc.normal
@@ -284,44 +296,116 @@ }
 
+// //------------------------------------------------------------------------------------------
+// //-- PM_ThreePointerTarget  ----------------------------------------------------------------
+// //------------------------------------------------------------------------------------------
+
+// export const PM_ThreePointerTarget = superclass => class extends PM_PointerTarget(superclass) {
+//     constructor(...args) {
+//         super(...args)
+//         const render = this.service("ThreeRenderManager");
+//     }
+
+//     destroy() {
+//         super.destroy();
+//         const render = this.service("ThreeRenderManager");
+//         if (!render.layers.pointer) return;
+//         const i = render.layers.pointer.indexOf(this.renderObject);
+//         if (i === -1) return;
+//         render.layers.pointer.splice(i,1);
+//     }
+
+//     // onSetRenderObject(renderObject) {
+//     //     if (super.onSetRenderObject) super.onSetRenderObject(renderObject)
+//     //     const render = this.service("ThreeRenderManager");
+//     //     render.layers.pointer.push(renderObject)
+//     // }
+// }
+
+
+// export const PM_LayerTarget = superclass => class extends superclass {
+//     constructor(...args) {
+//         super(...args);
+//      }
+
+//     destroy() {
+//         super.destroy();
+//         const render = this.service("ThreeRenderManager");
+
+//         if(this.layers)
+//         this.layers.forEach( layer => {
+//             if (render.layers[layer]){
+//                 const i = render.layers[layer].indexOf(this.renderObject);
+//                 if(i>=0) render.layers[layer].splice(i,1);
+//             }
+//         });
+//     }
+
+//     // onSetRenderObject(renderObject) {
+//     //     if (super.onSetRenderObject) super.onSetRenderObject(renderObject);
+//     //     const render = this.service("ThreeRenderManager");
+//     //     if(this.layers)
+//     //     this.layers.forEach( layer =>{
+//     //         if(!render.layers[layer])render.layers[layer]=[];
+//     //         render.layers[layer].push(renderObject);
+//     //     })
+//     // }
+// }
+
 //------------------------------------------------------------------------------------------
-//-- PM_ThreePointerTarget  ----------------------------------------------------------------
+//-- WidgetActor ---------------------------------------------------------------------------
 //------------------------------------------------------------------------------------------
 
-export const PM_ThreePointerTarget = superclass => class extends PM_PointerTarget(superclass) {
-    constructor(...args) {
-        super(...args)
-        const render = this.service("ThreeRenderManager");
-    }
+// export class WidgetActor extends mix(Actor).with(AM_Predictive, AM_PointerTarget) {
+//     get pawn() { return WidgetPawn; }
 
-    destroy() {
-        super.destroy();
-        const render = this.service("ThreeRenderManager");
-        if (!render.layers.pointer) return;
-        const i = render.layers.pointer.indexOf(this.renderObject);
-        if (i === -1) return;
-        render.layers.pointer.splice(i,1);
-    }
+//     get size() { return this._size || [100,100];}
+//     get anchor() { return this._anchor || [0,0];}
+//     get pivot() { return this._pivot || [0,0];}
+//     get autoSize() { return this._autoSize || [0,0];}
+//     get isVisible() { return this._visible === undefined || this._visible;} // Default to true
+//     get color() { return this._color || [0,0,0];}
 
-    onSetRenderObject(renderObject) {
-        if (super.onSetRenderObject) super.onSetRenderObject(renderObject)
-        const render = this.service("ThreeRenderManager");
-        render.layers.pointer.push(renderObject)
-    }
-}
 
+// }
+// WidgetActor.register('WidgetActor');
+
+
 // //------------------------------------------------------------------------------------------
-// //-- CardActor ------------------------------------------------------------------------------
+// //-- WidgetPawn ---------------------------------------------------------------------------
 // //------------------------------------------------------------------------------------------
 
-// export class CardActor extends mix(Actor).with(AM_Predictive, AM_PointerTarget) {
+// export class WidgetPawn extends mix(Pawn).with(PM_Predictive, PM_ThreeVisible, PM_ThreePointerTarget) {
 
-//     get pawn() { return CardPawn; }
+//     constructor(...args) {
+//         super(... args);
+//     }
 
+//     get size() { return this.actor.size; }
+//     get anchor() { return this.actor.anchor }
+//     get pivot() { return this.actor.pivot }
+//     get autoSize() { return this.actor.autoSize }
+//     get isVisible() { return this.actor.isVisible} // Default to true
+//     get color() { return this.actor.color }
+
 // }
-// CardActor.register('CardActor');
 
-// //------------------------------------------------------------------------------------------
-// //-- CardPawn ------------------------------------------------------------------------------
-// //------------------------------------------------------------------------------------------
 
-// export class CardPawn extends mix(Pawn).with(PM_Predictive, PM_ThreeVisible, PM_ThreePointerTarget) {
-// }
+/*
+
+//------------------------------------------------------------------------------------------
+//-- CardActor ------------------------------------------------------------------------------
+//------------------------------------------------------------------------------------------
+
+export class CardActor extends mix(Actor).with(AM_Predictive, AM_PointerTarget) {
+
+    get pawn() { return CardPawn; }
+
+}
+CardActor.register('CardActor');
+
+//------------------------------------------------------------------------------------------
+//-- CardPawn ------------------------------------------------------------------------------
+//------------------------------------------------------------------------------------------
+
+export class CardPawn extends mix(Pawn).with(PM_Predictive, PM_PointerTarget) {
+}
+*/

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

37172

increased by185.19%

Number of package files

7

increased by16.67%

Lines of code

757

increased by199.21%

Worsened metrics

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• Updated@croquet/worldcore-kernel@^1.2.0

• Updated@croquet/worldcore-three@^1.2.0