x_ite 8.3.1 → 8.3.3

package/src/x_ite/Fields/SFString.js

@@ -47,7 +47,6 @@
 
 import X3DField     from "../Base/X3DField.js";
 import X3DConstants from "../Base/X3DConstants.js";
-import Generator    from "../InputOutput/Generator.js";
 
 const
    unescape = /\\(.)/g,
@@ -98,17 +97,17 @@ SFString .prototype = Object .assign (Object .create (X3DField .prototype),
       X3DField .prototype .set .call (this, "" + value);
    },
    valueOf: X3DField .prototype .getValue,
-   toStream: function (stream)
+   toStream: function (generator)
    {
-      stream .string += '"' + SFString .escape (this .getValue ()) + '"';
+      generator .string += '"' + SFString .escape (this .getValue ()) + '"';
    },
-   toVRMLStream: function (stream)
+   toVRMLStream: function (generator)
    {
-      this .toStream (stream);
+      this .toStream (generator);
    },
-   toXMLStream: function (stream)
+   toXMLStream: function (generator)
    {
-      stream .string += Generator .Get (stream) .XMLEncode (this .getValue ());
+      generator .string += generator .XMLEncode (this .getValue ());
    },
 });
 

package/src/x_ite/Fields/SFTime.js

@@ -77,17 +77,17 @@ SFTime .prototype = Object .assign (Object .create (X3DField .prototype),
       X3DField .prototype .set .call (this, +value);
    },
    valueOf: X3DField .prototype .getValue,
-   toStream: function (stream)
+   toStream: function (generator)
    {
-      stream .string += this .getValue ();
+      generator .string += this .getValue ();
    },
-   toVRMLStream: function (stream)
+   toVRMLStream: function (generator)
    {
-      this .toStream (stream);
+      this .toStream (generator);
    },
-   toXMLStream: function (stream)
+   toXMLStream: function (generator)
    {
-      this .toStream (stream);
+      this .toStream (generator);
    },
 });
 

package/src/x_ite/Fields/SFVecPrototypeTemplate.js

@@ -46,10 +46,11 @@
  ******************************************************************************/
 
 import X3DField  from "../Base/X3DField.js";
-import Generator from "../InputOutput/Generator.js";
 
 function SFVecPrototypeTemplate (TypeName, Type, ValueType, double)
 {
+   const _formatter = double ? "DoublePrecision" : "Precision";
+
    return Object .assign (Object .create (X3DField .prototype),
    {
       [Symbol .iterator]: function* ()
@@ -144,29 +145,28 @@ function SFVecPrototypeTemplate (TypeName, Type, ValueType, double)
       {
          return new (this .constructor) (ValueType .subtract (this .getValue (), vector .getValue ()));
       },
-      toStream: function (stream)
+      toStream: function (generator)
       {
          const
-            generator = Generator .Get (stream),
             value     = this .getValue (),
             category  = generator .Unit (this .getUnit ()),
             last      = value .length - 1;
 
          for (let i = 0; i < last; ++ i)
          {
-            stream .string += double ? generator .DoublePrecision (generator .ToUnit (category, value [i])) : generator .Precision (generator .ToUnit (category, value [i]));
-            stream .string += " ";
+            generator .string += generator [_formatter] (generator .ToUnit (category, value [i]));
+            generator .string += generator .Space ();
          }
 
-         stream .string += double ? generator .DoublePrecision (generator .ToUnit (category, value [last])) : generator .Precision (generator .ToUnit (category, value [last]));
+         generator .string += generator [_formatter] (generator .ToUnit (category, value [last]));
       },
-      toVRMLStream: function (stream)
+      toVRMLStream: function (generator)
       {
-         this .toStream (stream);
+         this .toStream (generator);
       },
-      toXMLStream: function (stream)
+      toXMLStream: function (generator)
       {
-         this .toStream (stream);
+         this .toStream (generator);
       },
    });
 }

package/src/x_ite/InputOutput/FileLoader.js

@@ -101,7 +101,7 @@ FileLoader .prototype = Object .assign (Object .create (X3DObject .prototype),
    {
       return this .URL;
    },
-   createX3DFromString: function (worldURL, string, success, error)
+   createX3DFromString: function (worldURL, string = "", success, error)
    {
       try
       {

package/src/x_ite/InputOutput/Generator.js

@@ -47,13 +47,16 @@
 
 import X3DConstants from "../Base/X3DConstants.js";
 
-function Generator ()
+function Generator ({ style = "TIDY", precision = 6, doublePrecision = 14 })
 {
+   this .Style (style);
+
+   this .string              = "";
    this .indent              = "";
-   this .indentChar          = "  ";
-   this .precision           = 6;
-   this .doublePrecision     = 14;
-   this .removeTrailingZeros = /\.?0*(?=$|[eE])/;
+   this .listIndent          = "";
+   this .precision           = precision;
+   this .doublePrecision     = doublePrecision;
+   this .removeTrailingZeros = /(?:\.|(\.[0-9]*?))0*(?=[eE]|$)/;
 
    this .executionContextStack = [ null ];
    this .importedNodesIndex    = new Map ();
@@ -75,17 +78,122 @@ function Generator ()
 Generator .prototype =
 {
    constructor: Generator,
+   Style: function (style)
+   {
+      switch (style)
+      {
+         case "CLEAN":
+         {
+            this .comma          = " ";
+            this .break          = " ";
+            this .tidyBreak      = "";
+            this .tidySpace      = "";
+            this .indentChar     = "";
+            this .listEnclosure  = "";
+            this .listBreak      = "";
+            this .listIndentChar = "";
+            this .attribBreak    = " ";
+            break;
+         }
+         case "SMALL":
+         {
+            this .comma          = ",";
+            this .break          = "\n";
+            this .tidyBreak      = "\n";
+            this .tidySpace      = "";
+            this .indentChar     = "";
+            this .listEnclosure  = "";
+            this .listBreak      = "";
+            this .listIndentChar = "";
+            this .attribBreak    = " ";
+            break;
+         }
+         case "COMPACT":
+         {
+            this .comma          = ",";
+            this .break          = "\n";
+            this .tidyBreak      = "\n";
+            this .tidySpace      = " ";
+            this .indentChar     = "  ";
+            this .listEnclosure  = "";
+            this .listBreak      = " ";
+            this .listIndentChar = "";
+            this .attribBreak    = " ";
+            break;
+         }
+         case "TIDY":
+         default:
+         {
+            this .comma          = ",";
+            this .break          = "\n";
+            this .tidyBreak      = "\n";
+            this .tidySpace      = " ";
+            this .indentChar     = "  ";
+            this .listEnclosure  = "\n";
+            this .listBreak      = "\n";
+            this .listIndentChar = "  ";
+            this .attribBreak    = "\n";
+            break;
+         }
+      }
+   },
+   Comma: function ()
+   {
+      return this .comma;
+   },
+   Break: function ()
+   {
+      return this .break;
+   },
+   TidyBreak: function ()
+   {
+      return this .tidyBreak;
+   },
+   ForceBreak: function ()
+   {
+      return "\n";
+   },
+   Space: function ()
+   {
+      return " ";
+   },
+   TidySpace: function ()
+   {
+      return this .tidySpace;
+   },
+   ListStart: function ()
+   {
+      return this .listEnclosure;
+   },
+   ListEnd: function ()
+   {
+      return this .listEnclosure;
+   },
+   ListBreak: function ()
+   {
+      return this .listBreak;
+   },
+   AttribBreak: function ()
+   {
+      return this .attribBreak;
+   },
    Indent: function ()
    {
       return this .indent;
    },
+   ListIndent: function ()
+   {
+      return this .listIndent;
+   },
    IncIndent: function ()
    {
-      this .indent += this .indentChar;
+      this .indent     += this .indentChar;
+      this .listIndent += this .listIndentChar;
    },
    DecIndent: function ()
    {
-      this .indent = this .indent .substr (0, this .indent .length - this .indentChar .length);
+      this .indent = this .indent .slice (0, this .indent .length - this .indentChar .length);
+      this .listIndent = this .listIndent .slice (0, this .listIndent .length - this .listIndentChar .length);
    },
    PadRight: function (string, pad)
    {
@@ -96,11 +204,11 @@ Generator .prototype =
    },
    Precision: function (value)
    {
-      return Math .fround (value) .toPrecision (this .precision) .replace (this .removeTrailingZeros, "");
+      return Math .fround (value) .toPrecision (this .precision) .replace (this .removeTrailingZeros, "$1");
    },
    DoublePrecision: function (value)
    {
-      return value .toPrecision (this .doublePrecision) .replace (this .removeTrailingZeros, "");
+      return value .toPrecision (this .doublePrecision) .replace (this .removeTrailingZeros, "$1");
    },
    PushExecutionContext: function (executionContext)
    {
@@ -416,12 +524,4 @@ Generator .prototype =
 for (const key of Reflect .ownKeys (Generator .prototype))
    Object .defineProperty (Generator .prototype, key, { enumerable: false });
 
-Generator .Get = function (stream)
-{
-   if (! stream .generator)
-      stream .generator = new Generator ();
-
-   return stream .generator;
-};
-
 export default Generator;

package/src/x_ite/Parser/VRMLParser.js

@@ -443,11 +443,11 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
 
       if (this .success)
       {
-         this .loadComponents () .then (function ()
+         this .loadComponents () .then (() =>
          {
             try
             {
-               this .statements ();
+               this .statements (this .getScene () .rootNodes);
 
                if (this .lastIndex < this .input .length)
                   throw new Error ("Unknown statement.");
@@ -459,17 +459,12 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
                //console .error (error);
                this .error (new Error (this .getError (error)));
             }
-         }
-         .bind (this))
-         .catch (function (error)
-         {
-            this .error (error);
-         }
-         .bind (this));
+         })
+         .catch (this .error .bind (this));
       }
       else
       {
-         this .statements ();
+         this .statements (this .getScene () .rootNodes);
 
          if (this .lastIndex < this .input .length)
             throw new Error ("Unknown statement.");
@@ -730,12 +725,12 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
       }
       return false;
    },
-   statements: function ()
+   statements: function (field)
    {
-      while (this .statement ())
+      while (this .statement (field))
          ;
    },
-   statement: function ()
+   statement: function (field)
    {
       if (this .protoStatement ())
          return true;
@@ -753,7 +748,7 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
 
       if (node !== false)
       {
-         this .addRootNode (node);
+         field .push (node);
          return true;
       }
 
@@ -835,7 +830,7 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
                      this .pushPrototype (proto);
                      this .pushExecutionContext (proto .getBody ());
 
-                     this .protoBody ();
+                     this .protoBody (proto .getBody () .rootNodes);
 
                      this .popExecutionContext ();
                      this .popPrototype ();
@@ -877,16 +872,16 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
 
       return false;
    },
-   protoBody: function ()
+   protoBody: function (rootNodes)
    {
       this .protoStatements ();
 
-      var rootNodeStatement = this .rootNodeStatement ();
+      const rootNodeStatement = this .rootNodeStatement ();
 
       if (rootNodeStatement !== false)
-         this .addRootNode (rootNodeStatement);
+         rootNodes .push (rootNodeStatement);
 
-      this .statements ();
+      this .statements (rootNodes);
    },
    rootNodeStatement: function ()
    {
@@ -1323,11 +1318,11 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
       {
          var
             nodeTypeId = this .result [1],
-            baseNode   = this .getExecutionContext () .createNode (nodeTypeId, false);
+            baseNode   = this .getExecutionContext () .createProto (nodeTypeId, false);
 
          if (! baseNode)
          {
-            baseNode = this .getExecutionContext () .createProto (nodeTypeId, false);
+            baseNode = this .getExecutionContext () .createNode (nodeTypeId, false);
 
             if (! baseNode)
                throw new Error ("Unknown node type or proto '" + nodeTypeId + "', you probably have insufficient component/profile statements.");
@@ -2409,14 +2404,16 @@ VRMLParser .prototype = Object .assign (Object .create (X3DParser .prototype),
    },
    nodeStatements: function (field)
    {
-      var node = this .nodeStatement ();
+      this .statements (field);
 
-      while (node !== false)
-      {
-         field .push (node);
+      // var node = this .nodeStatement ();
 
-         node = this .nodeStatement ();
-      }
+      // while (node !== false)
+      // {
+      //    field .push (node);
+
+      //    node = this .nodeStatement ();
+      // }
    },
    sfrotationValue: function (field)
    {

package/src/x_ite/Parser/X3DParser.js

@@ -91,10 +91,6 @@ X3DParser .prototype = {
    {
       return Boolean (this .prototypes .length);
    },
-   addRootNode: function (node)
-   {
-      this .getExecutionContext () .rootNodes .push (node);
-   },
    loadComponents: (function ()
    {
       const VRML =