x_ite 8.3.2 → 8.4.0

package/src/x_ite/Fields/SFMatrixPrototypeTemplate.js

@@ -45,11 +45,12 @@
  *
  ******************************************************************************/
 
-import X3DField  from "../Base/X3DField.js";
-import Generator from "../InputOutput/Generator.js";
+import X3DField from "../Base/X3DField.js";
 
 function SFMatrixPrototypeTemplate (TypeName, Type, Matrix, SFVec, double)
 {
+   const _formatter = double ? "DoublePrecision" : "Precision";
+
    return Object .assign (Object .create (X3DField .prototype),
    {
       [Symbol .iterator]: function* ()
@@ -136,28 +137,52 @@ function SFMatrixPrototypeTemplate (TypeName, Type, Matrix, SFVec, double)
       {
          return new SFVec (this .getValue () .multMatrixDir (vector .getValue () .copy ()));
       },
-      toStream: function (stream)
+      toStream: function (generator)
       {
          const
-            generator = Generator .Get (stream),
-            value     = this .getValue (),
-            last      = value .length - 1;
+            value = this .getValue (),
+            last  = value .length - 1;
 
          for (let i = 0; i < last; ++ i)
          {
-            stream .string += double ? generator .DoublePrecision (value [i]) : generator .Precision (value [i]);
-            stream .string += " ";
+            generator .string += generator [_formatter] (value [i]);
+            generator .string += generator .TidySpace ();
          }
 
-         stream .string += double ? generator .DoublePrecision (value [last]) : generator .Precision (value [last]);
+         generator .string += generator [_formatter] (value [last]);
+      },
+      toVRMLStream: function (generator)
+      {
+         this .toStream (generator);
       },
-      toVRMLStream: function (stream)
+      toXMLStream: function (generator)
       {
-         this .toStream (stream);
+         this .toStream (generator);
+      },
+      toJSONStream: function (generator)
+      {
+         generator .string += '[';
+         generator .string += generator .TidySpace ();
+
+         this .toJSONStreamValue (generator);
+
+         generator .string += generator .TidySpace ();
+         generator .string += ']';
       },
-      toXMLStream: function (stream)
+      toJSONStreamValue: function (generator)
       {
-         this .toStream (stream);
+         const
+            value = this .getValue (),
+            last  = value .length - 1;
+
+         for (let i = 0; i < last; ++ i)
+         {
+            generator .string += generator .JSONNumber (generator [_formatter] (value [i]));
+            generator .string += ',';
+            generator .string += generator .TidySpace ();
+         }
+
+         generator .string += generator .JSONNumber (generator [_formatter] (value [last]));
       },
    });
 }

package/src/x_ite/Fields/SFNode.js

@@ -372,54 +372,92 @@ SFNode .prototype = Object .assign (Object .create (X3DField .prototype),
 
       return null;
    },
-   toStream: function (stream)
+   toVRMLString: function (options = Object .prototype)
+   {
+      const
+         generator = new Generator (options),
+         value     = this .getValue ();
+
+      if (value)
+         generator .PushExecutionContext (value .getExecutionContext ());
+
+      this .toVRMLStream (generator);
+
+      return generator .string;
+   },
+   toXMLString: function (options = Object .prototype)
+   {
+      const
+         generator = new Generator (options),
+         value     = this .getValue ();
+
+      if (value)
+         generator .PushExecutionContext (value .getExecutionContext ());
+
+      this .toXMLStream (generator);
+
+      return generator .string;
+   },
+   toJSONString: function (options = Object .prototype)
+   {
+      const
+         generator = new Generator (options),
+         value     = this .getValue ();
+
+      if (value)
+         generator .PushExecutionContext (value .getExecutionContext ());
+
+      this .toJSONStream (generator);
+
+      return generator .string;
+   },
+   toStream: function (generator)
    {
       const
          target = this [_target],
          value  = target .getValue ();
 
       if (value)
-         value .toStream (stream);
+         value .toStream (generator);
       else
-         stream .string += "NULL";
+         generator .string += "NULL";
    },
-   toVRMLStream: function (stream)
+   toVRMLStream: function (generator)
    {
       const
          target = this [_target],
          value  = target .getValue ();
 
       if (value)
-         value .toVRMLStream (stream);
+         value .toVRMLStream (generator);
       else
-         stream .string += "NULL";
+         generator .string += "NULL";
    },
-   toXMLString: function ()
+   toXMLStream: function (generator)
    {
       const
-         target    = this [_target],
-         stream    = { string: "" },
-         generator = Generator .Get (stream),
-         value     = target .getValue ();
-
-      generator .PushExecutionContext (value .getExecutionContext ());
-
-      target .toXMLStream (stream);
-
-      generator .PopExecutionContext ();
+         target = this [_target],
+         value  = target .getValue ();
 
-      return stream .string;
+      if (value)
+         value .toXMLStream (generator);
+      else
+         generator .string += "<!-- NULL -->";
+   },
+   toJSONStream: function (generator)
+   {
+      this .toJSONStreamValue (generator);
    },
-   toXMLStream: function (stream)
+   toJSONStreamValue: function (generator)
    {
       const
          target = this [_target],
          value  = target .getValue ();
 
       if (value)
-         value .toXMLStream (stream);
+         value .toJSONStream (generator);
       else
-         stream .string += "<!-- NULL -->";
+         generator .string += "null";
    },
    dispose: function ()
    {

package/src/x_ite/Fields/SFRotation.js

@@ -49,7 +49,6 @@ import X3DField     from "../Base/X3DField.js";
 import SFVec3       from "./SFVec3.js";
 import SFMatrix3    from "./SFMatrix3.js";
 import X3DConstants from "../Base/X3DConstants.js";
-import Generator    from "../InputOutput/Generator.js";
 import Rotation4    from "../../standard/Math/Numbers/Rotation4.js";
 import Matrix3      from "../../standard/Math/Numbers/Matrix3.js";
 
@@ -153,24 +152,50 @@ SFRotation .prototype = Object .assign (Object .create (X3DField .prototype),
    {
       return new SFRotation (Rotation4 .slerp (this .getValue (), rotation .getValue (), t));
    },
-   toStream: function (stream)
+   toStream: function (generator)
    {
-      const
-         generator = Generator .Get (stream),
-         rotation  = this .getValue ();
+      const rotation = this .getValue ();
 
-      stream .string += generator .DoublePrecision (rotation .x) + " " +
-                        generator .DoublePrecision (rotation .y) + " " +
-                        generator .DoublePrecision (rotation .z) + " " +
-                        generator .DoublePrecision (generator .ToUnit ("angle", rotation .angle));
+      generator .string += generator .DoublePrecision (rotation .x);
+      generator .string += generator .TidySpace ();
+      generator .string += generator .DoublePrecision (rotation .y);
+      generator .string += generator .TidySpace ();
+      generator .string += generator .DoublePrecision (rotation .z);
+      generator .string += generator .TidySpace ();
+      generator .string += generator .DoublePrecision (generator .ToUnit ("angle", rotation .angle));
    },
-   toVRMLStream: function (stream)
+   toVRMLStream: function (generator)
    {
-      this .toStream (stream);
+      this .toStream (generator);
    },
-   toXMLStream: function (stream)
+   toXMLStream: function (generator)
    {
-      this .toStream (stream);
+      this .toStream (generator);
+   },
+   toJSONStream: function (generator)
+   {
+      generator .string += '[';
+      generator .string += generator .TidySpace ();
+
+      this .toJSONStreamValue (generator);
+
+      generator .string += generator .TidySpace ();
+      generator .string += ']';
+   },
+   toJSONStreamValue: function (generator)
+   {
+      const rotation = this .getValue ();
+
+      generator .string += generator .JSONNumber (generator .DoublePrecision (rotation .x));
+      generator .string += ',';
+      generator .string += generator .TidySpace ();
+      generator .string += generator .JSONNumber (generator .DoublePrecision (rotation .y));
+      generator .string += ',';
+      generator .string += generator .TidySpace ();
+      generator .string += generator .JSONNumber (generator .DoublePrecision (rotation .z));
+      generator .string += ',';
+      generator .string += generator .TidySpace ();
+      generator .string += generator .JSONNumber (generator .DoublePrecision (generator .ToUnit ("angle", rotation .angle)));
    },
 });
 

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,25 @@ 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 ());
+   },
+   toJSONStream: function (generator)
+   {
+      this .toJSONStreamValue (generator)
+   },
+   toJSONStreamValue: function (generator)
+   {
+      generator .string += generator .JSONEncode (this .getValue ());
    },
 });
 

package/src/x_ite/Fields/SFTime.js

@@ -77,17 +77,25 @@ 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);
+   },
+   toJSONStream: function (generator)
+   {
+      this .toJSONStreamValue (generator);
+   },
+   toJSONStreamValue: function (generator)
+   {
+      generator .string += generator .JSONNumber (generator .DoublePrecision (this .getValue ()));
    },
 });
 

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,54 @@ 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;
+            value    = this .getValue (),
+            last     = value .length - 1,
+            category = generator .Unit (this .getUnit ());
 
          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 .TidySpace ();
          }
 
-         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 (generator)
+      {
+         this .toStream (generator);
       },
-      toVRMLStream: function (stream)
+      toXMLStream: function (generator)
       {
-         this .toStream (stream);
+         this .toStream (generator);
+      },
+      toJSONStream: function (generator)
+      {
+         generator .string += '[';
+         generator .string += generator .TidySpace ();
+
+         this .toJSONStreamValue (generator);
+
+         generator .string += generator .TidySpace ();
+         generator .string += ']';
       },
-      toXMLStream: function (stream)
+      toJSONStreamValue: function (generator)
       {
-         this .toStream (stream);
+         const
+            value = this .getValue (),
+            last  = value .length - 1,
+            category  = generator .Unit (this .getUnit ());
+
+         for (let i = 0; i < last; ++ i)
+         {
+            generator .string += generator .JSONNumber (generator [_formatter] (generator .ToUnit (category, value [i])));
+            generator .string += ',';
+            generator .string += generator .TidySpace ();
+         }
+
+         generator .string += generator .JSONNumber (generator [_formatter] (generator .ToUnit (category, value [last])));
       },
    });
 }

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,126 @@ 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;
+
+      return "";
    },
    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);
+
+      return "";
    },
    PadRight: function (string, pad)
    {
@@ -96,11 +208,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)
    {
@@ -411,17 +523,66 @@ Generator .prototype =
    {
       return string .replace (/\]\]\>/g, "\\]\\]\\>");
    },
-};
+   JSONEncode: function (string)
+   {
+      let result = '"';
 
-for (const key of Reflect .ownKeys (Generator .prototype))
-   Object .defineProperty (Generator .prototype, key, { enumerable: false });
+      for (const character of string)
+      {
+         switch (character)
+         {
+            case '\r':
+            {
+               result += "\\r";
+               break;
+            }
+            case '\n':
+            {
+               result += "\\n";
+               break;
+            }
+            case '\t':
+            {
+               result += "\\t";
+               break;
+            }
+            case '"':
+            {
+               result += "\\\"";
+               break;
+            }
+            case '\\':
+            {
+               result += "\\\\";
+               break;
+            }
+            default:
+            {
+               result += character;
+               break;
+            }
+         }
+      }
 
-Generator .Get = function (stream)
-{
-   if (! stream .generator)
-      stream .generator = new Generator ();
+      result += '"';
 
-   return stream .generator;
+      return result;
+   },
+   JSONNumber: function (value)
+   {
+      switch (value)
+      {
+         case "NaN":
+         case "Infinity":
+         case "-Infinity":
+            return '"' + value + '"';
+         default:
+            return value;
+      }
+   },
 };
 
+for (const key of Reflect .ownKeys (Generator .prototype))
+   Object .defineProperty (Generator .prototype, key, { enumerable: false });
+
 export default Generator;

package/src/x_ite/Parser/JSONParser.js

@@ -73,7 +73,7 @@ JSONParser .prototype = Object .assign (Object .create (X3DParser .prototype),
       try
       {
          if (typeof json === "string")
-            json = JSON .parse (json)
+            json = JSON .parse (json);
 
          this .input = json;
       }