diff --git a/components/ConversionPanel.js b/components/ConversionPanel.js
index 55a3659..bd51461 100644
--- a/components/ConversionPanel.js
+++ b/components/ConversionPanel.js
@@ -346,7 +346,7 @@ export default class ConversionPanel extends PureComponent {
theme={theme}
name="code"
readOnly
- value={window.js_beautify(resultValue, { e4x: true })}
+ value={rightMode ==! "rust" ? window.js_beautify(resultValue, { e4x: true }) : resultValue}
editorProps={{ $blockScrolling: true }}
scrollMargin={[20]}
fontSize={14}
diff --git a/components/Layout.js b/components/Layout.js
index f7df20c..e7f031c 100644
--- a/components/Layout.js
+++ b/components/Layout.js
@@ -202,6 +202,11 @@ export default function({ children, pathname }) {
HTML to JSX
+
+
+ JSON to Rust Serde
+
+
diff --git a/pages/json-to-rust-serde.js b/pages/json-to-rust-serde.js
new file mode 100644
index 0000000..8989965
--- /dev/null
+++ b/pages/json-to-rust-serde.js
@@ -0,0 +1,38 @@
+import React, { PureComponent } from "react";
+import dynamic from "next/dynamic";
+import { Json2dts, toValidJSON } from "../utils/json-to-rust-serde";
+import Layout from "../components/Layout";
+import ConversionPanel from "../components/ConversionPanel";
+import defaultText from "../utils/dummy-json";
+
+export default class Json2Ts extends PureComponent {
+ getTransformedValue = newValue => {
+ const converter = new Json2dts();
+ let text2Obj = JSON.parse(toValidJSON(newValue));
+ if (typeof text2Obj !== "object" || Array.isArray(text2Obj)) {
+ throw new Error(
+ "Pass a valid JSON Object. Arrays are not acceptable even though they are valid JSON."
+ );
+ }
+ converter.parse(text2Obj, "RootJson");
+
+ return converter.getCode();
+ };
+
+ render() {
+ return (
+
+
+
+ );
+ }
+}
diff --git a/utils/json-to-rust-serde.js b/utils/json-to-rust-serde.js
new file mode 100644
index 0000000..efb77ff
--- /dev/null
+++ b/utils/json-to-rust-serde.js
@@ -0,0 +1,524 @@
+var is;
+(function(is) {
+ var ObjProto = Object.prototype;
+ var ArrayProto = Array.prototype;
+ var toString = ObjProto.toString;
+ var hasOwn = ObjProto.hasOwnProperty;
+ var index_of = ArrayProto.indexOf
+ ? function(arr, val) {
+ return arr.indexOf(val);
+ }
+ : function(arr, val) {
+ for (var i = 0, l = arr.length; i < l; i++) {
+ if (arr[i] === val) {
+ return i;
+ }
+ }
+ return -1;
+ };
+ function string(s) {
+ return typeof s === "string" || s instanceof String;
+ }
+ is.string = string;
+ function number(n) {
+ return typeof n === "number" || n instanceof Number;
+ }
+ is.number = number;
+ function boolean(b) {
+ return b === !!b || b instanceof Boolean;
+ }
+ is.boolean = boolean;
+ function fn(f) {
+ return typeof f === "function";
+ }
+ is.fn = fn;
+ is.array =
+ Array.isArray ||
+ function(a) {
+ return toString.call(a) === "[object Array]";
+ };
+ function object(o) {
+ return o === Object(o);
+ }
+ is.object = object;
+ function regex(r) {
+ return !!(
+ r &&
+ r.test &&
+ r.exec &&
+ (r.ignoreCase || r.ignoreCase === false)
+ );
+ }
+ is.regex = regex;
+ is.element =
+ typeof HTMLElement !== "undefined"
+ ? function(e) {
+ return e instanceof HTMLElement;
+ }
+ : function(e) {
+ return !!(e && e.nodeType === 1);
+ };
+ function numeric(n) {
+ return !isNaN(parseFloat(n)) && isFinite(n);
+ }
+ is.numeric = numeric;
+ function hash(o) {
+ if (
+ !o ||
+ typeof o !== "object" ||
+ is.element(o) ||
+ (typeof window !== "undefined" && o === window) ||
+ (o.constructor &&
+ !hasOwn.call(o, "constructor") &&
+ !hasOwn.call(o.constructor.prototype, "isPrototypeOf"))
+ ) {
+ return false;
+ }
+ for (var key in o) {
+ }
+ return key === undefined || hasOwn.call(o, key);
+ }
+ is.hash = hash;
+ function inside(container, val) {
+ if (is.array(container)) {
+ return index_of(container, val) > -1;
+ } else if (is.object(container)) {
+ for (var prop in container) {
+ if (hasOwn.call(container, prop) && container[prop] === val) {
+ return true;
+ }
+ }
+ return false;
+ } else {
+ return false;
+ }
+ }
+ is.inside = inside;
+ function set(v) {
+ return v !== null && v !== void 0;
+ }
+ is.set = set;
+ function empty(container) {
+ if (is.array(container)) {
+ return container.length === 0;
+ } else if (is.object(container)) {
+ if (is.fn(container.valueOf) && !is.object(container.valueOf())) {
+ return is.empty(container.valueOf());
+ }
+ for (var x in container) {
+ if (hasOwn.call(container, x)) {
+ return false;
+ }
+ }
+ return true;
+ } else {
+ return !container;
+ }
+ }
+ is.empty = empty;
+})(is || (is = {}));
+function SHA1(msg) {
+ function rotate_left(n, s) {
+ var t4 = (n << s) | (n >>> (32 - s));
+ return t4;
+ }
+ function lsb_hex(val) {
+ var str = "";
+ var i;
+ var vh;
+ var vl;
+ for (i = 0; i <= 6; i += 2) {
+ vh = (val >>> (i * 4 + 4)) & 0x0f;
+ vl = (val >>> (i * 4)) & 0x0f;
+ str += vh.toString(16) + vl.toString(16);
+ }
+ return str;
+ }
+ function cvt_hex(val) {
+ var str = "";
+ var i;
+ var v;
+ for (i = 7; i >= 0; i--) {
+ v = (val >>> (i * 4)) & 0x0f;
+ str += v.toString(16);
+ }
+ return str;
+ }
+ function Utf8Encode(string) {
+ string = string.replace(/\r\n/g, "\n");
+ var utftext = "";
+ for (var n = 0; n < string.length; n++) {
+ var c = string.charCodeAt(n);
+ if (c < 128) {
+ utftext += String.fromCharCode(c);
+ } else if (c > 127 && c < 2048) {
+ utftext += String.fromCharCode((c >> 6) | 192);
+ utftext += String.fromCharCode((c & 63) | 128);
+ } else {
+ utftext += String.fromCharCode((c >> 12) | 224);
+ utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+ utftext += String.fromCharCode((c & 63) | 128);
+ }
+ }
+ return utftext;
+ }
+ var blockstart;
+ var i, j;
+ var W = new Array(80);
+ var H0 = 0x67452301;
+ var H1 = 0xefcdab89;
+ var H2 = 0x98badcfe;
+ var H3 = 0x10325476;
+ var H4 = 0xc3d2e1f0;
+ var A, B, C, D, E;
+ var temp;
+ msg = Utf8Encode(msg);
+ var msg_len = msg.length;
+ var word_array = new Array();
+ for (i = 0; i < msg_len - 3; i += 4) {
+ j =
+ (msg.charCodeAt(i) << 24) |
+ (msg.charCodeAt(i + 1) << 16) |
+ (msg.charCodeAt(i + 2) << 8) |
+ msg.charCodeAt(i + 3);
+ word_array.push(j);
+ }
+ switch (msg_len % 4) {
+ case 0:
+ i = 0x080000000;
+ break;
+ case 1:
+ i = (msg.charCodeAt(msg_len - 1) << 24) | 0x0800000;
+ break;
+ case 2:
+ i =
+ (msg.charCodeAt(msg_len - 2) << 24) |
+ (msg.charCodeAt(msg_len - 1) << 16) |
+ 0x08000;
+ break;
+ case 3:
+ i =
+ (msg.charCodeAt(msg_len - 3) << 24) |
+ (msg.charCodeAt(msg_len - 2) << 16) |
+ (msg.charCodeAt(msg_len - 1) << 8) |
+ 0x80;
+ break;
+ }
+ word_array.push(i);
+ while (word_array.length % 16 != 14) word_array.push(0);
+ word_array.push(msg_len >>> 29);
+ word_array.push((msg_len << 3) & 0x0ffffffff);
+ for (blockstart = 0; blockstart < word_array.length; blockstart += 16) {
+ for (i = 0; i < 16; i++) W[i] = word_array[blockstart + i];
+ for (i = 16; i <= 79; i++)
+ W[i] = rotate_left(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
+ A = H0;
+ B = H1;
+ C = H2;
+ D = H3;
+ E = H4;
+ for (i = 0; i <= 19; i++) {
+ temp =
+ (rotate_left(A, 5) + ((B & C) | (~B & D)) + E + W[i] + 0x5a827999) &
+ 0x0ffffffff;
+ E = D;
+ D = C;
+ C = rotate_left(B, 30);
+ B = A;
+ A = temp;
+ }
+ for (i = 20; i <= 39; i++) {
+ temp =
+ (rotate_left(A, 5) + (B ^ C ^ D) + E + W[i] + 0x6ed9eba1) & 0x0ffffffff;
+ E = D;
+ D = C;
+ C = rotate_left(B, 30);
+ B = A;
+ A = temp;
+ }
+ for (i = 40; i <= 59; i++) {
+ temp =
+ (rotate_left(A, 5) +
+ ((B & C) | (B & D) | (C & D)) +
+ E +
+ W[i] +
+ 0x8f1bbcdc) &
+ 0x0ffffffff;
+ E = D;
+ D = C;
+ C = rotate_left(B, 30);
+ B = A;
+ A = temp;
+ }
+ for (i = 60; i <= 79; i++) {
+ temp =
+ (rotate_left(A, 5) + (B ^ C ^ D) + E + W[i] + 0xca62c1d6) & 0x0ffffffff;
+ E = D;
+ D = C;
+ C = rotate_left(B, 30);
+ B = A;
+ A = temp;
+ }
+ H0 = (H0 + A) & 0x0ffffffff;
+ H1 = (H1 + B) & 0x0ffffffff;
+ H2 = (H2 + C) & 0x0ffffffff;
+ H3 = (H3 + D) & 0x0ffffffff;
+ H4 = (H4 + E) & 0x0ffffffff;
+ }
+ var temp2 =
+ cvt_hex(H0) + cvt_hex(H1) + cvt_hex(H2) + cvt_hex(H3) + cvt_hex(H4);
+ return temp2.toLowerCase();
+}
+var Types = (function() {
+ function Types() {}
+ Types.STRING = "String";
+ Types.NUMBER = "u64";
+ Types.BOOLEAN = "boolean";
+ Types.ARRAY = "[]";
+ return Types;
+})();
+exports.Types = Types;
+var Json2dts = (function() {
+ function Json2dts() {
+ this.is_value_consistent = function(o) {
+ var _this = this;
+ if (this.size(o) == 0) {
+ return true;
+ } else {
+ if (!is.array(o)) {
+ o = this.values(o);
+ }
+ var n = o[0];
+ var nn = is.object(n) ? this.generate_signature(n) : typeof n;
+ return Object.keys(o).every(function(key) {
+ return (
+ (is.object(o[key])
+ ? _this.generate_signature(o[key])
+ : typeof o[key]) == nn
+ );
+ });
+ }
+ };
+ }
+ Json2dts.prototype.parse = function(obj, objectName, moduleName) {
+ if (objectName === void 0) {
+ objectName = "_RootInterface";
+ }
+ if (moduleName === void 0) {
+ moduleName = "";
+ }
+ this.moduleName = moduleName;
+ this.classes = {};
+ this.classesCache = {};
+ this.classesInUse = {};
+ this.analyse_object(obj, objectName);
+ return this.classes;
+ };
+ Json2dts.prototype.getCode = function(flow) {
+ var _this = this;
+ var output;
+ var classes = {};
+ var outputModule = this.moduleName == "" ? false : true;
+ var interfaceTab = outputModule ? "\t" : "";
+ var propertyTab = interfaceTab + "\t";
+ Object.keys(this.classes).map(function(clsName) {
+ output = interfaceTab + "#[derive(Serialize, Deserialize)]\nstruct " + clsName + " \n" + interfaceTab + "{\n";
+ Object.keys(_this.classes[clsName]).map(function(key) {
+ output += propertyTab + key + ": " + _this.classes[clsName][key] + ",\n";
+ });
+ output += interfaceTab + "}\n\n";
+ classes[clsName] = output;
+ });
+ output = "";
+ Object.keys(classes).sort().forEach(function(key) {
+ output += classes[key];
+ });
+
+ return output;
+ };
+ Json2dts.prototype.analyse_object = function(obj, objectName) {
+ var _this = this;
+ if (objectName === void 0) {
+ objectName = "json";
+ }
+ objectName = this.getInterfaceType(objectName, obj);
+ this.classes[objectName] = this.classes[objectName] || {};
+ Object.keys(obj).map(function(key) {
+ var type = "string";
+ var sha = "";
+ var value = obj[key];
+ switch (true) {
+ case is.string(value):
+ type = Types.STRING;
+ break;
+ case is.number(value):
+ type = Types.NUMBER;
+ break;
+ case is.boolean(value):
+ type = Types.BOOLEAN;
+ break;
+ case is.array(value):
+ type = "Vec<()>";
+ if (_this.is_value_consistent(value)) {
+ if (_this.size(value) == 0) {
+ type = "Vec<()>";
+ } else {
+ if (is.object(value[0])) {
+ type = "Vec<" + _this.getInterfaceType(key, value[0]).trim() + ">";
+ _this.analyse_object(value[0], key);
+ } else {
+ type = "Vec<" + _this.getBasicType(value[0]) + ">";
+ }
+ }
+ }
+ break;
+ case is.object(value) && !is.array(value):
+ type = "()";
+ if (!is.empty(value)) {
+ type = _this.getInterfaceType(key, value);
+ _this.analyse_object(value, key);
+ }
+ break;
+ }
+ if (_this.hasSpecialChars(key)) {
+ key = '"' + key + '"';
+ }
+ _this.classes[objectName][key] = type;
+ });
+ };
+ Json2dts.prototype.objectParser = function(key) {};
+ Json2dts.prototype.getBasicType = function(value) {
+ var type = Types.STRING;
+ switch (true) {
+ case is.string(value):
+ type = Types.STRING;
+ break;
+ case is.number(value):
+ type = Types.NUMBER;
+ break;
+ case is.boolean(value):
+ type = Types.BOOLEAN;
+ break;
+ }
+ return type;
+ };
+ Json2dts.prototype.getInterfaceType = function(key, value) {
+ // get a valid className
+ key = key
+ .replace(/_/gi, " ")
+ .replace(/-/gi, " ")
+ .replace(/\w\S*/g, function(txt) {
+ return txt.charAt(0).toUpperCase() + txt.substr(1);
+ })
+ .replace(/ /gi, "");
+ var currentObjectSignature = this.generate_signature(value);
+ var isKnownClass =
+ Object.keys(this.classesCache).indexOf(currentObjectSignature) != -1;
+ if (isKnownClass) return this.classesCache[currentObjectSignature];
+ if (this.classesInUse[key] != undefined) {
+ this.classesInUse[key]++;
+ this.classesCache[currentObjectSignature] = key + this.classesInUse[key];
+ return this.classesCache[currentObjectSignature];
+ }
+ this.classesCache[currentObjectSignature] = key;
+ this.classesInUse[key] = 0;
+ return key;
+ };
+ Json2dts.prototype.size = function(obj) {
+ if (obj == null) return 0;
+ return obj.length === +obj.length ? obj.length : Object.keys(obj).length;
+ };
+ Json2dts.prototype.values = function(obj) {
+ return Object.keys(obj).map(function(key) {
+ return obj[key];
+ });
+ };
+ Json2dts.prototype.generate_signature = function(o) {
+ if (is.object(o)) {
+ return SHA1(
+ Object.keys(o)
+ .map(function(n) {
+ return n.toLowerCase();
+ })
+ .sort()
+ .join("|")
+ );
+ } else {
+ return SHA1(
+ Object.keys(o)
+ .map(function(n) {
+ return typeof n;
+ })
+ .sort()
+ .join("|")
+ );
+ }
+ };
+ Json2dts.prototype.hasSpecialChars = function(str) {
+ return /[ ~`!#$%\^&*+=\-\[\]\\';,\/{}|\\":<>\?]/g.test(str);
+ };
+ Json2dts.prototype.keysrt = function(key, desc) {
+ if (desc === void 0) {
+ desc = false;
+ }
+ return function(a, b) {
+ return desc ? ~~(a[key] < b[key]) : ~~(a[key] > b[key]);
+ };
+ };
+ return Json2dts;
+})();
+exports.Json2dts = Json2dts;
+function extractLineFeeds(s) {
+ return s.replace(/[^\n]+/g, "");
+}
+function toValidJSON(input, keepLineNumbers) {
+ if (keepLineNumbers === void 0) {
+ keepLineNumbers = false;
+ }
+ var UNESCAPE_MAP = { '\\"': '"', "\\`": "`", "\\'": "'" };
+ var ML_ESCAPE_MAP = { "\n": "\\n", "\r": "\\r", "\t": "\\t", '"': '\\"' };
+ function unescapeQuotes(r) {
+ return UNESCAPE_MAP[r] || r;
+ }
+ return input
+ .replace(
+ /`(?:\\.|[^`])*`|'(?:\\.|[^'])*'|"(?:\\.|[^"])*"|\/\*[^]*?\*\/|\/\/.*\n?/g,
+ function(s) {
+ if (s.charAt(0) == "/") {
+ return keepLineNumbers ? extractLineFeeds(s) : "";
+ } else {
+ return s;
+ }
+ }
+ )
+ .replace(
+ /(?:true|false|null)(?=[^\w_$]|$)|([a-zA-Z_$][\w_$]*)|`((?:\\.|[^`])*)`|'((?:\\.|[^'])*)'|"(?:\\.|[^"])*"|(,)(?=\s*[}\]])/g,
+ function(s, identifier, multilineQuote, singleQuote, lonelyComma) {
+ if (lonelyComma) {
+ return "";
+ } else if (identifier != null) {
+ return '"' + identifier + '"';
+ } else if (multilineQuote != null) {
+ return (
+ '"' +
+ multilineQuote
+ .replace(/\\./g, unescapeQuotes)
+ .replace(/[\n\r\t"]/g, function(r) {
+ return ML_ESCAPE_MAP[r];
+ }) +
+ '"' +
+ (keepLineNumbers ? extractLineFeeds(multilineQuote) : "")
+ );
+ } else if (singleQuote != null) {
+ return (
+ '"' +
+ singleQuote.replace(/\\./g, unescapeQuotes).replace(/"/g, '\\"') +
+ '"'
+ );
+ } else {
+ return s;
+ }
+ }
+ );
+}
+exports.toValidJSON = toValidJSON;