x_ite 8.7.9 → 8.8.1

package/src/x_ite/Base/X3DChildObject.js

@@ -45,76 +45,185 @@
  *
  ******************************************************************************/
 
-import X3DObject from "./X3DObject.js";
+import X3DObject   from "./X3DObject.js";
+import DEVELOPMENT from "../DEVELOPMENT.js";
 
 const
    _modificationTime = Symbol (),
    _tainted          = Symbol (),
-   _parents          = Symbol ();
+   _parents          = Symbol (),
+   _registry         = Symbol ();
 
 function X3DChildObject ()
 {
    X3DObject .call (this);
 }
 
-X3DChildObject .prototype = Object .assign (Object .create (X3DObject .prototype),
+if (DEVELOPMENT)
 {
-   constructor: X3DChildObject,
-   [_modificationTime]: 0,
-   [_tainted]: false,
-   [_parents]: new Set (),
-   setModificationTime: function (value)
+   Object .assign (Object .setPrototypeOf (X3DChildObject .prototype, X3DObject .prototype),
    {
-      this [_modificationTime] = value;
-   },
-   getModificationTime: function ()
-   {
-      return this [_modificationTime];
-   },
-   setTainted: function (value)
-   {
-      this [_tainted] = value;
-   },
-   isTainted: function ()
-   {
-      return this [_tainted];
-   },
-   addEvent: function ()
-   {
-      this .setModificationTime (Date .now ());
+      [_modificationTime]: 0,
+      [_tainted]: false,
+      [_parents]: new Map (),
+      [_registry]: null,
+      isInitializable ()
+      {
+         return true;
+      },
+      isInput ()
+      {
+         return false;
+      },
+      isOutput ()
+      {
+         return false;
+      },
+      setModificationTime (value)
+      {
+         this [_modificationTime] = value;
+      },
+      getModificationTime ()
+      {
+         return this [_modificationTime];
+      },
+      setTainted (value)
+      {
+         this [_tainted] = value;
+      },
+      isTainted ()
+      {
+         return this [_tainted];
+      },
+      addEvent ()
+      {
+         this .setModificationTime (Date .now ());
 
-      for (const parent of this [_parents])
-         parent .addEvent (this);
-   },
-   addEventObject: function (field, event)
-   {
-      this .setModificationTime (Date .now ());
+         for (const parent of this [_parents] .values ())
+            parent .deref () .addEvent (this);
+      },
+      addEventObject (field, event)
+      {
+         this .setModificationTime (Date .now ());
 
-      for (const parent of this [_parents])
-         parent .addEventObject (this, event);
-   },
-   addParent: function (parent)
-   {
-      if (this [_parents] === X3DChildObject .prototype [_parents])
-         this [_parents] = new Set ();
+         for (const parent of this [_parents] .values ())
+            parent .deref () .addEventObject (this, event);
+      },
+      addParent (parent)
+      {
+         if (this [_parents] === X3DChildObject .prototype [_parents])
+         {
+            this [_parents]  = new Map ();
+            this [_registry] = new FinalizationRegistry (id => this [_parents] .delete (id));
+         }
 
-      this [_parents] .add (parent);
-   },
-   removeParent: function (parent)
-   {
-      this [_parents] .delete (parent);
-   },
-   getParents: function ()
-   {
-      return this [_parents];
-   },
-   dispose: function ()
+         this [_parents] .set (parent .getId (), new WeakRef (parent));
+         this [_registry] .register (parent, parent .getId (), parent);
+      },
+      removeParent (parent)
+      {
+         this [_parents] .delete (parent .getId ());
+         this [_registry] ?.unregister (parent);
+      },
+      getParents ()
+      {
+         const parents = new Set ();
+
+         for (const weakRef of this [_parents] .values ())
+            parents .add (weakRef .deref ())
+
+         return parents;
+      },
+      processEvent ()
+      {
+         this .setTainted (false);
+         this .processInterests ();
+      },
+      dispose ()
+      {
+         this [_parents] .clear ();
+
+         X3DObject .prototype .dispose .call (this);
+      },
+   });
+}
+else
+{
+   Object .assign (Object .setPrototypeOf (X3DChildObject .prototype, X3DObject .prototype),
    {
-      this [_parents] .clear ();
+      [_modificationTime]: 0,
+      [_tainted]: false,
+      [_parents]: new Set (),
+      isInitializable ()
+      {
+         return true;
+      },
+      isInput ()
+      {
+         return false;
+      },
+      isOutput ()
+      {
+         return false;
+      },
+      setModificationTime (value)
+      {
+         this [_modificationTime] = value;
+      },
+      getModificationTime ()
+      {
+         return this [_modificationTime];
+      },
+      setTainted (value)
+      {
+         this [_tainted] = value;
+      },
+      isTainted ()
+      {
+         return this [_tainted];
+      },
+      addEvent ()
+      {
+         this .setModificationTime (Date .now ());
 
-      X3DObject .prototype .dispose .call (this);
-   },
-});
+         for (const parent of this [_parents])
+            parent .addEvent (this);
+      },
+      addEventObject (field, event)
+      {
+         this .setModificationTime (Date .now ());
+
+         for (const parent of this [_parents])
+            parent .addEventObject (this, event);
+      },
+      addParent (parent)
+      {
+         if (this [_parents] === X3DChildObject .prototype [_parents])
+            this [_parents] = new Set ();
+
+         this [_parents] .add (parent);
+      },
+      removeParent (parent)
+      {
+         this [_parents] .delete (parent);
+      },
+      getParents ()
+      {
+         return this [_parents];
+      },
+      processEvent ()
+      {
+         this .setTainted (false);
+         this .processInterests ();
+      },
+      dispose ()
+      {
+         this [_parents] .clear ();
+
+         X3DObject .prototype .dispose .call (this);
+      },
+   });
+}
 
 for (const key of Reflect .ownKeys (X3DChildObject .prototype))
    Object .defineProperty (X3DChildObject .prototype, key, { enumerable: false });

package/src/x_ite/Base/X3DConstants.js

@@ -46,26 +46,27 @@
  ******************************************************************************/
 
 let
-   browserEvent = 0,
-   loadState    = 0,
-   fieldType    = 0;
+   BROWSER_EVENT = 0,
+   LOAD_STATE    = 0,
+   FIELD_TYPE    = 0,
+   NODE_TYPE     = 0;
 
 const X3DConstants =
 {
    // Browser event
 
-   CONNECTION_ERROR:  browserEvent ++,
-   BROWSER_EVENT:     browserEvent ++,
-   INITIALIZED_EVENT: browserEvent ++,
-   SHUTDOWN_EVENT:    browserEvent ++,
-   INITIALIZED_ERROR: browserEvent ++,
+   CONNECTION_ERROR:  BROWSER_EVENT ++,
+   BROWSER_EVENT:     BROWSER_EVENT ++,
+   INITIALIZED_EVENT: BROWSER_EVENT ++,
+   SHUTDOWN_EVENT:    BROWSER_EVENT ++,
+   INITIALIZED_ERROR: BROWSER_EVENT ++,
 
    // Load state
 
-   NOT_STARTED_STATE: loadState ++,
-   IN_PROGRESS_STATE: loadState ++,
-   COMPLETE_STATE:    loadState ++,
-   FAILED_STATE:      loadState ++,
+   NOT_STARTED_STATE: LOAD_STATE ++,
+   IN_PROGRESS_STATE: LOAD_STATE ++,
+   COMPLETE_STATE:    LOAD_STATE ++,
+   FAILED_STATE:      LOAD_STATE ++,
 
    // Access type
 
@@ -76,57 +77,70 @@ const X3DConstants =
 
    // X3DField
 
-   SFBool:      fieldType ++,
-   SFColor:     fieldType ++,
-   SFColorRGBA: fieldType ++,
-   SFDouble:    fieldType ++,
-   SFFloat:     fieldType ++,
-   SFImage:     fieldType ++,
-   SFInt32:     fieldType ++,
-   SFMatrix3d:  fieldType ++,
-   SFMatrix3f:  fieldType ++,
-   SFMatrix4d:  fieldType ++,
-   SFMatrix4f:  fieldType ++,
-   SFNode:      fieldType ++,
-   SFRotation:  fieldType ++,
-   SFString:    fieldType ++,
-   SFTime:      fieldType ++,
-   SFVec2d:     fieldType ++,
-   SFVec2f:     fieldType ++,
-   SFVec3d:     fieldType ++,
-   SFVec3f:     fieldType ++,
-   SFVec4d:     fieldType ++,
-   SFVec4f:     fieldType ++,
-
-   VrmlMatrix:  fieldType ++,
+   SFBool:      FIELD_TYPE ++,
+   SFColor:     FIELD_TYPE ++,
+   SFColorRGBA: FIELD_TYPE ++,
+   SFDouble:    FIELD_TYPE ++,
+   SFFloat:     FIELD_TYPE ++,
+   SFImage:     FIELD_TYPE ++,
+   SFInt32:     FIELD_TYPE ++,
+   SFMatrix3d:  FIELD_TYPE ++,
+   SFMatrix3f:  FIELD_TYPE ++,
+   SFMatrix4d:  FIELD_TYPE ++,
+   SFMatrix4f:  FIELD_TYPE ++,
+   SFNode:      FIELD_TYPE ++,
+   SFRotation:  FIELD_TYPE ++,
+   SFString:    FIELD_TYPE ++,
+   SFTime:      FIELD_TYPE ++,
+   SFVec2d:     FIELD_TYPE ++,
+   SFVec2f:     FIELD_TYPE ++,
+   SFVec3d:     FIELD_TYPE ++,
+   SFVec3f:     FIELD_TYPE ++,
+   SFVec4d:     FIELD_TYPE ++,
+   SFVec4f:     FIELD_TYPE ++,
+
+   VrmlMatrix:  FIELD_TYPE ++,
 
    // X3DArrayField
 
-   MFBool:      fieldType ++,
-   MFColor:     fieldType ++,
-   MFColorRGBA: fieldType ++,
-   MFDouble:    fieldType ++,
-   MFFloat:     fieldType ++,
-   MFImage:     fieldType ++,
-   MFInt32:     fieldType ++,
-   MFMatrix3d:  fieldType ++,
-   MFMatrix3f:  fieldType ++,
-   MFMatrix4d:  fieldType ++,
-   MFMatrix4f:  fieldType ++,
-   MFNode:      fieldType ++,
-   MFRotation:  fieldType ++,
-   MFString:    fieldType ++,
-   MFTime:      fieldType ++,
-   MFVec2d:     fieldType ++,
-   MFVec2f:     fieldType ++,
-   MFVec3d:     fieldType ++,
-   MFVec3f:     fieldType ++,
-   MFVec4d:     fieldType ++,
-   MFVec4f:     fieldType ++,
-
-   // Abstract node
-
-   X3DBaseNode: 0,
+   MFBool:      FIELD_TYPE ++,
+   MFColor:     FIELD_TYPE ++,
+   MFColorRGBA: FIELD_TYPE ++,
+   MFDouble:    FIELD_TYPE ++,
+   MFFloat:     FIELD_TYPE ++,
+   MFImage:     FIELD_TYPE ++,
+   MFInt32:     FIELD_TYPE ++,
+   MFMatrix3d:  FIELD_TYPE ++,
+   MFMatrix3f:  FIELD_TYPE ++,
+   MFMatrix4d:  FIELD_TYPE ++,
+   MFMatrix4f:  FIELD_TYPE ++,
+   MFNode:      FIELD_TYPE ++,
+   MFRotation:  FIELD_TYPE ++,
+   MFString:    FIELD_TYPE ++,
+   MFTime:      FIELD_TYPE ++,
+   MFVec2d:     FIELD_TYPE ++,
+   MFVec2f:     FIELD_TYPE ++,
+   MFVec3d:     FIELD_TYPE ++,
+   MFVec3f:     FIELD_TYPE ++,
+   MFVec4d:     FIELD_TYPE ++,
+   MFVec4f:     FIELD_TYPE ++,
+
+   // Abstract nodes and nodes types are added later.
+
+   X3DBaseNode: NODE_TYPE,
+
+   [Symbol .toStringTag]: "X3DConstants",
 };
 
+Object .defineProperty (X3DConstants, "addNode",
+{
+   value ({ typeName })
+   {
+      if (this [typeName])
+         return;
+
+      this [typeName] = ++ NODE_TYPE;
+   },
+});
+
 export default X3DConstants;

package/src/x_ite/Base/X3DEventObject.js

@@ -57,19 +57,18 @@ function X3DEventObject (browser)
    this [_browser] = browser;
 }
 
-X3DEventObject .prototype = Object .assign (Object .create (X3DChildObject .prototype),
+Object .assign (Object .setPrototypeOf (X3DEventObject .prototype, X3DChildObject .prototype),
 {
-   constructor: X3DEventObject,
-   getBrowser: function ()
+   getBrowser ()
    {
       return this [_browser];
    },
-   getExtendedEventHandling: function ()
+   getExtendedEventHandling ()
    {
       // Whether initializeOnly field are treated like inputOnly and inputOutput fields.
       return true;
    },
-   addEvent: function (field)
+   addEvent (field)
    {
       if (field .isTainted ())
          return;
@@ -78,7 +77,7 @@ X3DEventObject .prototype = Object .assign (Object .create (X3DChildObject .prot
 
       this .addEventObject (field, Events .create (field));
    },
-   addEventObject: function (field, event)
+   addEventObject (field, event)
    {
       const browser = this .getBrowser ();
 
@@ -97,7 +96,7 @@ X3DEventObject .prototype = Object .assign (Object .create (X3DChildObject .prot
          this .addNodeEvent ();
       }
    },
-   addNodeEvent: function ()
+   addNodeEvent ()
    {
       if (this .isTainted ())
          return;
@@ -108,11 +107,6 @@ X3DEventObject .prototype = Object .assign (Object .create (X3DChildObject .prot
       browser .addTaintedNode (this);
       browser .addBrowserEvent ();
    },
-   processEvents: function ()
-   {
-      this .setTainted (false);
-      this .processInterests ();
-   },
 });
 
 for (const key of Reflect .ownKeys (X3DEventObject .prototype))