x_ite 8.7.9 → 8.8.0

package/src/x_ite/Base/X3DField.js

@@ -70,9 +70,8 @@ function X3DField (value)
    this [_value] = value;
 }
 
-X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype),
+Object .assign (Object .setPrototypeOf (X3DField .prototype, X3DChildObject .prototype),
 {
-   constructor: X3DField,
    [_value]: null,
    [_accessType]: X3DConstants .initializeOnly,
    [_unit]: null,
@@ -84,80 +83,84 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
    [_outputRoutes]: new Set (),
    [_routeCallbacks]: new Map (),
    [_uniformLocation]: null,
-   create: function ()
+   create ()
    {
       return new (this .constructor) ();
    },
-   equals: function (field)
+   equals (field)
    {
       return this [_value] === field .valueOf ();
    },
-   assign: function (field)
+   assign (field)
    {
       // Assigns field to this field.
       this .set (field .getValue ());
       this .addEvent ();
    },
-   set: function (value)
+   set (value)
    {
       // Sets internal value without generating event.
       this [_value] = value;
    },
-   setValue: function (value)
+   setValue (value)
    {
       // Sets internal value and generates event.
       this .set (value instanceof this .constructor ? value .getValue () : value);
       this .addEvent ();
    },
-   getValue: function ()
+   getValue ()
    {
       return this [_value];
    },
-   setAccessType: function (value)
+   getType ()
+   {
+      return X3DConstants [this .constructor .typeName];
+   },
+   setAccessType (value)
    {
       this [_accessType] = value;
    },
-   getAccessType: function ()
+   getAccessType ()
    {
       return this [_accessType];
    },
-   isInitializable: function ()
+   isInitializable ()
    {
       return !! (this [_accessType] & X3DConstants .initializeOnly);
    },
-   isInput: function ()
+   isInput ()
    {
       return !! (this [_accessType] & X3DConstants .inputOnly);
    },
-   isOutput: function ()
+   isOutput ()
    {
       return !! (this [_accessType] & X3DConstants .outputOnly);
    },
-   isReadable: function ()
+   isReadable ()
    {
       return this [_accessType] !== X3DConstants .inputOnly;
    },
-   isWritable: function ()
+   isWritable ()
    {
       return this [_accessType] !== X3DConstants .outputOnly;
    },
-   setUnit: function (value)
+   setUnit (value)
    {
       this [_unit] = value;
    },
-   getUnit: function ()
+   getUnit ()
    {
       return this [_unit];
    },
-   hasReferences: function ()
+   hasReferences ()
    {
       return this [_references] .size !== 0;
    },
-   isReference: function (accessType)
+   isReference (accessType)
    {
       return accessType === this [_accessType] || accessType === X3DConstants .inputOutput;
    },
-   addReference: function (reference)
+   addReference (reference)
    {
       const references = this .getReferences ();
 
@@ -189,7 +192,7 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
 
       this .processReferencesCallbacks ();
    },
-   removeReference: function (reference)
+   removeReference (reference)
    {
       this .getReferences () .delete (reference);
 
@@ -214,25 +217,25 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
 
       this .processReferencesCallbacks ();
    },
-   getReferences: function ()
+   getReferences ()
    {
       if (this [_references] === X3DField .prototype [_references])
          this [_references] = new Set ();
 
       return this [_references];
    },
-   addReferencesCallback: function (key, object)
+   addReferencesCallback (key, object)
    {
       if (this [_referencesCallbacks] === X3DField .prototype [_referencesCallbacks])
          this [_referencesCallbacks] = new Map ();
 
       this [_referencesCallbacks] .set (key, object);
    },
-   removeReferencesCallback: function (key)
+   removeReferencesCallback (key)
    {
       this [_referencesCallbacks] .delete (key);
    },
-   getReferencesCallbacks: function ()
+   getReferencesCallbacks ()
    {
       return this [_referencesCallbacks];
    },
@@ -249,37 +252,37 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
          }
       };
    })(),
-   addFieldInterest: function (field)
+   addFieldInterest (field)
    {
       if (this [_fieldInterests] === X3DField .prototype [_fieldInterests])
          this [_fieldInterests] = new Set ();
 
       this [_fieldInterests] .add (field);
    },
-   removeFieldInterest: function (field)
+   removeFieldInterest (field)
    {
       this [_fieldInterests] .delete (field);
    },
-   getFieldInterests: function ()
+   getFieldInterests ()
    {
       return this [_fieldInterests];
    },
-   addFieldCallback: function (key, object)
+   addFieldCallback (key, object)
    {
       if (this [_fieldCallbacks] === X3DField .prototype [_fieldCallbacks])
          this [_fieldCallbacks] = new Map ();
 
       this [_fieldCallbacks] .set (key, object);
    },
-   removeFieldCallback: function (key)
+   removeFieldCallback (key)
    {
       this [_fieldCallbacks] .delete (key);
    },
-   getFieldCallbacks: function ()
+   getFieldCallbacks ()
    {
       return this [_fieldCallbacks];
    },
-   addInputRoute: function (route)
+   addInputRoute (route)
    {
       if (this [_inputRoutes] === X3DField .prototype [_inputRoutes])
          this [_inputRoutes] = new Set ();
@@ -288,17 +291,17 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
 
       this .processRouteCallbacks ();
    },
-   removeInputRoute: function (route)
+   removeInputRoute (route)
    {
       this [_inputRoutes] .delete (route);
 
       this .processRouteCallbacks ();
    },
-   getInputRoutes: function ()
+   getInputRoutes ()
    {
       return this [_inputRoutes];
    },
-   addOutputRoute: function (route)
+   addOutputRoute (route)
    {
       if (this [_outputRoutes] === X3DField .prototype [_outputRoutes])
          this [_outputRoutes] = new Set ();
@@ -307,17 +310,17 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
 
       this .processRouteCallbacks ();
    },
-   removeOutputRoute: function (route)
+   removeOutputRoute (route)
    {
       this [_outputRoutes] .delete (route);
 
       this .processRouteCallbacks ();
    },
-   getOutputRoutes: function ()
+   getOutputRoutes ()
    {
       return this [_outputRoutes];
    },
-   addRouteCallback: function (key, object)
+   addRouteCallback (key, object)
    {
       // Processed if routes are changed.
 
@@ -326,11 +329,11 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
 
       this [_routeCallbacks] .set (key, object);
    },
-   removeRouteCallback: function (key)
+   removeRouteCallback (key)
    {
       this [_routeCallbacks] .delete (key);
    },
-   getRouteCallbacks: function ()
+   getRouteCallbacks ()
    {
       return this [_routeCallbacks];
    },
@@ -400,11 +403,11 @@ X3DField .prototype = Object .assign (Object .create (X3DChildObject .prototype)
    })(),
    addCloneCount: Function .prototype,
    removeCloneCount: Function .prototype,
-   fromString: function (string, scene)
+   fromString (string, scene)
    {
       // Function will be overridden in VRMLParser.
    },
-   dispose: function ()
+   dispose ()
    {
       this [_references]          .clear ();
       this [_referencesCallbacks] .clear ();

package/src/x_ite/Base/X3DFieldDefinition.js

@@ -58,16 +58,18 @@ function X3DFieldDefinition (accessType, name, value)
    });
 }
 
-X3DFieldDefinition .prototype = Object .assign (Object .create (X3DObject .prototype),
+Object .setPrototypeOf (X3DFieldDefinition .prototype, X3DObject .prototype);
+
+for (const key of Reflect .ownKeys (X3DFieldDefinition .prototype))
+   Object .defineProperty (X3DFieldDefinition .prototype, key, { enumerable: false });
+
+Object .defineProperties (X3DFieldDefinition,
 {
-   constructor: X3DFieldDefinition,
-   getTypeName: function ()
+   typeName:
    {
-      return "X3DFieldDefinition";
+      value: "X3DFieldDefinition",
+      enumerable: true,
    },
 });
 
-for (const key of Reflect .ownKeys (X3DFieldDefinition .prototype))
-   Object .defineProperty (X3DFieldDefinition .prototype, key, { enumerable: false });
-
 export default X3DFieldDefinition;

package/src/x_ite/Base/X3DInfoArray.js

@@ -45,15 +45,16 @@
  *
  ******************************************************************************/
 
-import Generator from "../InputOutput/Generator.js";
+import X3DChildObject from "./X3DChildObject.js";
 
 const
-   _array = Symbol (),
-   _index = Symbol ();
+   _array     = Symbol (),
+   _index     = Symbol (),
+   _valueType = Symbol ();
 
 const handler =
 {
-   get: function (target, key)
+   get (target, key)
    {
       const value = target [key];
 
@@ -70,7 +71,7 @@ const handler =
          return;
       }
    },
-   set: function (target, key, value)
+   set (target, key, value)
    {
       if (target [key] === undefined)
          return false;
@@ -78,18 +79,18 @@ const handler =
       target [key] = value;
       return true;
    },
-   has: function (target, key)
+   has (target, key)
    {
       if (Number .isInteger (+key))
          return key < target [_array] .length;
 
       return key in target;
    },
-   ownKeys: function (target)
+   ownKeys (target)
    {
       return Object .keys (target [_array]);
    },
-   getOwnPropertyDescriptor: function (target, key)
+   getOwnPropertyDescriptor (target, key)
    {
       if (typeof key !== "string")
          return;
@@ -108,36 +109,47 @@ const handler =
    },
 };
 
-function X3DInfoArray (values, ValueType)
+function X3DInfoArray (values, valueType)
 {
-   this [_array] = [ ];
-   this [_index] = new Map ();
+   const proxy = new Proxy (this, handler);
 
-   if (values)
-   {
-      for (const value of values)
-      {
-         if (!(value instanceof ValueType))
-            throw new TypeError (`Wrong type in construction of ${this .getTypeName ()}.`);
+   X3DChildObject .call (this);
 
-         this .add (value .name, value);
-      }
-   }
+   this [_array]     = [ ];
+   this [_index]     = new Map ();
+   this [_valueType] = valueType;
+
+   for (const [key, value] of values)
+      this .add (key, value);
 
-   return new Proxy (this, handler);
+   return proxy;
 }
 
-X3DInfoArray .prototype = {
-   constructor: X3DInfoArray,
-   [Symbol .iterator]: function* ()
+Object .assign (Object .setPrototypeOf (X3DInfoArray .prototype, X3DChildObject .prototype),
+{
+   *[Symbol .iterator] ()
    {
       yield* this [_array];
    },
-   copy: function ()
+   copy ()
    {
-      return new (this .constructor) (this [_array]);
+      const copy = new (this .constructor) ();
+
+      copy .assign (this);
+
+      return copy;
    },
-   equals: function (array)
+   assign (array)
+   {
+      if (!(array instanceof this .constructor))
+         throw new Error ("Couldn't assign info array, wrong type.");
+
+      this [_array] = Array .from (array [_array]);
+      this [_index] = new Map (array [_index]);
+
+      this .addEvent ();
+   },
+   equals (array)
    {
       const
          a      = this [_array],
@@ -158,27 +170,40 @@ X3DInfoArray .prototype = {
 
       return true;
    },
-   has: function (key)
+   has (key)
    {
       return this [_index] .has (key);
    },
-   get: function (key)
+   get (key)
    {
       return this [_index] .get (key);
    },
-   add: function (key, value)
+   add (key, value)
    {
+      if (this [_index] .has (key))
+         throw new Error (`Couldn't add value to ${this .getTypeName ()}, key '${key}' already exists.`);
+
+      if (!(value instanceof this [_valueType]))
+         throw new Error (`Couldn't add value to ${this .getTypeName ()}, value for key '${key}' has wrong type.`);
+
       this [_array] .push (value);
       this [_index] .set (key, value);
+
+      this .addEvent ();
    },
-   addAlias: function (alias, key)
+   alias (alias, key)
    {
       this [_index] .set (alias, this [_index] .get (key));
+
+      this .addEvent ();
    },
-   update: function (oldKey, newKey, value)
+   update (oldKey, newKey, value)
    {
       // TODO: update alias.
 
+      if (!(value instanceof this [_valueType]))
+         throw new Error (`Couldn't update value of ${this .getTypeName ()}, value for key '${key}' has wrong type.`);
+
       const oldValue = this [_index] .get (oldKey);
 
       if (oldKey !== newKey)
@@ -198,8 +223,10 @@ X3DInfoArray .prototype = {
       {
          this [_array] .push (value);
       }
+
+      this .addEvent ();
    },
-   remove: function (key)
+   remove (key)
    {
       // TODO: remove alias.
 
@@ -214,6 +241,8 @@ X3DInfoArray .prototype = {
 
       if (index > -1)
          this [_array] .splice (index, 1);
+
+      this .addEvent ();
    },
    at: Array .prototype .at,
    // concat: Array .prototype .concat,
@@ -221,7 +250,7 @@ X3DInfoArray .prototype = {
    entries: Array .prototype .entries,
    every: Array .prototype .every,
    // fill: Array .prototype .fill,
-   filter: function (callbackFn, thisArg)
+   filter (callbackFn, thisArg)
    {
       return new (this .constructor) (Array .prototype .filter .call (this, callbackFn, thisArg));
    },
@@ -237,28 +266,28 @@ X3DInfoArray .prototype = {
    join: Array .prototype .join,
    keys: Array .prototype .keys,
    lastIndexOf: Array .prototype .lastIndexOf,
-   map: function (callbackFn, thisArg)
+   map (callbackFn, thisArg)
    {
       return new (this .constructor) (Array .prototype .map .call (this, callbackFn, thisArg));
    },
    reduce: Array .prototype .reduce,
    reduceRight: Array .prototype .reduceRight,
    // reverse: Array .prototype .reverse,
-   slice: function (start, end)
+   slice (start, end)
    {
       return new (this .constructor) (Array .prototype .slice .call (this, start, end));
    },
    some: Array .prototype .some,
    // sort: Array .prototype .sort,
-   toReversed: function ()
+   toReversed ()
    {
       return new (this .constructor) ([... this] .reverse ());
    },
-   toSorted: function (compareFn)
+   toSorted (compareFn)
    {
       return new (this .constructor) ([... this] .sort (compareFn));
    },
-   toSpliced: function (start, deleteCount, ... insertValues)
+   toSpliced (start, deleteCount, ... insertValues)
    {
       const array = [... this];
 
@@ -267,7 +296,7 @@ X3DInfoArray .prototype = {
       return new (this .constructor) (array);
    },
    values: Array .prototype .values,
-   with: function (index, value)
+   with (index, value)
    {
       const array = [... this];
 
@@ -275,22 +304,7 @@ X3DInfoArray .prototype = {
 
       return new (this .constructor) (array);
    },
-   toString: function (options = Object .prototype)
-   {
-      const generator = new Generator (options);
-
-      if (options .scene)
-         generator .PushExecutionContext (options .scene);
-
-      this .toStream (generator);
-
-      return generator .string;
-   },
-   toStream: function (generator)
-   {
-      generator .string = "[object " + this .getTypeName () + "]";
-   },
-   toVRMLStream: function (generator)
+   toVRMLStream (generator)
    {
       for (const value of this [_array])
       {
@@ -309,7 +323,7 @@ X3DInfoArray .prototype = {
          }
       }
    },
-   toXMLStream: function (generator)
+   toXMLStream (generator)
    {
       for (const value of this [_array])
       {
@@ -325,11 +339,11 @@ X3DInfoArray .prototype = {
          }
       }
    },
-   toJSONStream: function (generator, comma)
+   toJSONStream (generator, comma)
    {
       let lastProperty = false;
 
-      for (const [i, value] of this [_array] .entries ())
+      for (const value of this [_array])
       {
          try
          {
@@ -351,7 +365,7 @@ X3DInfoArray .prototype = {
 
       return lastProperty;
    },
-};
+});
 
 for (const key of Reflect .ownKeys (X3DInfoArray .prototype))
    Object .defineProperty (X3DInfoArray .prototype, key, { enumerable: false });
@@ -360,11 +374,7 @@ Object .defineProperties (X3DInfoArray .prototype,
 {
    length:
    {
-      get: function () { return this [_array] .length; },
-   },
-   [Symbol .toStringTag]:
-   {
-      get: function () { return this .getTypeName (); },
+      get () { return this [_array] .length; },
    },
 });