json-as 0.9.15 → 0.9.17

package/CHANGELOG

@@ -23,6 +23,8 @@ v0.9.12 - Add compat with aspect
 v0.9.13 - Fix empty strings not indexing correctly
 v0.9.14 - Ignore properties of type Function
 v0.9.15 - Support JSON.Raw blocks
+v0.9.16 - JSON.Raw should be completely untouched
+v0.9.17 - A schema's parent's fields should be included properly
 
 [UNRELEASED] v1.0.0
  - Allow nullable primitives

package/README.md

@@ -3,7 +3,7 @@
  __|  ||   __||     ||   | | ___ |  _  ||   __|
 |  |  ||__   ||  |  || | | ||___||     ||__   |
 |_____||_____||_____||_|___|     |__|__||_____|
-v0.9.15
+v0.9.17
 </pre>
 </h5>
 

package/assembly/test.ts

@@ -1,33 +1,28 @@
 // import { JSON } from ".";
 import { JSON } from ".";
 @json
-class Vec3 {
-  x: f32 = 0.0;
-  y: f32 = 0.0;
-  z: f32 = 0.0;
+class Message {
+  constructor(role: string, content: string) {
+    this._role = role;
+    this.content = content;
+  }
+
+
+  @alias("role")
+  protected _role: string;
+
+  get role(): string {
+    return this._role;
+  }
+
+  content: string;
 }
 
 @json
-class Player {
-  firstName!: string;
-  lastName!: string;
-  lastActive!: i32[];
-  age!: i32;
-  pos!: JSON.Raw;
-  isVerified!: boolean;
+class UserMessage extends Message {
+  constructor(content: string) {
+    super("user", content);
+  }
 }
-
-const player: Player = {
-  firstName: "Emmet",
-  lastName: "West",
-  lastActive: [8, 27, 2022],
-  age: 23,
-  pos: "{\"x\":3.4,\"y\":1.2,\"z\":8.3}",
-  isVerified: true
-};
-
-const stringified = JSON.stringify<Player>(player);
-console.log(stringified);
-console.log(idof<JSON.Raw>().toString());
-console.log(idof<string>().toString())
-// const parsed = JSON.parse<Player>(stringified);
+console.log(JSON.stringify(new Message("user", "foo")))
+console.log(JSON.stringify(new UserMessage("foo")));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "0.9.15",
+  "version": "0.9.17",
   "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "types": "assembly/index.ts",
   "author": "Jairus Tanaka",

package/transform/lib/index.js

@@ -31,10 +31,11 @@ class JSONTransform extends BaseVisitor {
         if (node.extendsType) {
             schema.parent = this.schemasList.find((v) => v.name == node.extendsType?.name.identifier.text);
             if (schema.parent?.members) {
-                for (let i = 0; i < schema.parent.members.length; i++) {
+                for (let i = schema.parent.members.length - 1; i >= 0; i--) {
                     const replace = schema.members.find((v) => v.name == schema.parent?.members[i]?.name);
                     if (!replace) {
-                        schema.members.unshift(schema.parent.members[i]);
+                        //schema.members.unshift(schema.parent?.members[i]!);
+                        members.unshift(schema.parent?.members[i].node);
                     }
                 }
             }
@@ -118,8 +119,8 @@ class JSONTransform extends BaseVisitor {
             if (!mem.flags.length) {
                 mem.flags = [PropertyFlags.None];
                 if (type == "JSON.Raw") {
-                    mem.serialize = escapeString(JSON.stringify(mem.alias || mem.name)) + ":${__SERIALIZE<string>(this." + name.text + ")}";
-                    mem.deserialize = "this." + name.text + " = " + "__DESERIALIZE<string>(data.substring(value_start, value_end));";
+                    mem.serialize = escapeString(JSON.stringify(mem.alias || mem.name)) + ":${this." + name.text + "}";
+                    mem.deserialize = "this." + name.text + " = " + "data.substring(value_start, value_end);";
                 }
                 else {
                     mem.serialize = escapeString(JSON.stringify(mem.alias || mem.name)) + ":${__SERIALIZE<" + type + ">(this." + name.text + ")}";

package/transform/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@json-as/transform",
-  "version": "0.9.15",
+  "version": "0.9.17",
   "description": "The only JSON library you'll need for AssemblyScript. SIMD enabled",
   "main": "./lib/index.js",
   "author": "Jairus Tanaka",

package/transform/src/index.ts

@@ -48,12 +48,13 @@ class JSONTransform extends BaseVisitor {
       ) as SchemaData | null;
 
       if (schema.parent?.members) {
-        for (let i = 0; i < schema.parent.members.length; i++) {
+        for (let i = schema.parent.members.length - 1; i >= 0; i--) {
           const replace = schema.members.find(
             (v) => v.name == schema.parent?.members[i]?.name
           );
           if (!replace) {
-            schema.members.unshift(schema.parent.members[i]!);
+            //schema.members.unshift(schema.parent?.members[i]!);
+            members.unshift(schema.parent?.members[i]!.node);
           }
         }
       }
@@ -136,8 +137,8 @@ class JSONTransform extends BaseVisitor {
       if (!mem.flags.length) {
         mem.flags = [PropertyFlags.None];
         if (type == "JSON.Raw") {
-          mem.serialize = escapeString(JSON.stringify(mem.alias || mem.name)) + ":${__SERIALIZE<string>(this." + name.text + ")}";
-          mem.deserialize = "this." + name.text + " = " + "__DESERIALIZE<string>(data.substring(value_start, value_end));"
+          mem.serialize = escapeString(JSON.stringify(mem.alias || mem.name)) + ":${this." + name.text + "}";
+          mem.deserialize = "this." + name.text + " = " + "data.substring(value_start, value_end);"
         } else {
           mem.serialize = escapeString(JSON.stringify(mem.alias || mem.name)) + ":${__SERIALIZE<" + type + ">(this." + name.text + ")}";
           mem.deserialize = "this." + name.text + " = " + "__DESERIALIZE<" + type + ">(data.substring(value_start, value_end));"

package/transform/lib/visitor.js

@@ -1,516 +0,0 @@
-import { ArrayLiteralExpression, AssertionExpression, BinaryExpression, CallExpression, ElementAccessExpression, FloatLiteralExpression, FunctionTypeNode, IdentifierExpression, NamedTypeNode, Node, ObjectLiteralExpression, Source, TypeParameterNode, BlockStatement, BreakStatement, ClassDeclaration, ClassExpression, CommaExpression, ContinueStatement, DecoratorNode, DoStatement, EmptyStatement, EnumDeclaration, EnumValueDeclaration, ExportDefaultStatement, ExportImportStatement, ExportMember, ExportStatement, ExpressionStatement, FieldDeclaration, ForStatement, FunctionDeclaration, FunctionExpression, IfStatement, ImportDeclaration, ImportStatement, IndexSignatureNode, InstanceOfExpression, IntegerLiteralExpression, InterfaceDeclaration, LiteralExpression, MethodDeclaration, NamespaceDeclaration, NewExpression, ParameterNode, ParenthesizedExpression, PropertyAccessExpression, RegexpLiteralExpression, ReturnStatement, StringLiteralExpression, SwitchCase, SwitchStatement, TemplateLiteralExpression, TernaryExpression, ThrowStatement, TryStatement, TypeDeclaration, TypeName, UnaryPostfixExpression, UnaryPrefixExpression, VariableDeclaration, VariableStatement, WhileStatement, } from "assemblyscript/dist/assemblyscript.js";
-export class Visitor {
-    constructor() {
-        this.currentSource = null;
-        this.depth = 0;
-    }
-    visit(node) {
-        if (node == null) {
-            return;
-        }
-        else if (node instanceof Array) {
-            for (const element of node) {
-                this.visit(element);
-            }
-        }
-        else if (node instanceof Map) {
-            for (const element of node.values()) {
-                this.visit(element);
-            }
-            // @ts-ignore
-        }
-        else if (typeof node[Symbol.iterator] === "function") {
-            // @ts-ignore
-            for (const element of node) {
-                this.visit(element);
-            }
-        }
-        else if (node instanceof Node) {
-            this._visit(node);
-        }
-        else {
-            throw new Error("Could not visit invalid type!");
-        }
-    }
-    _visit(node) {
-        if (node instanceof Source) {
-            this.visitSource(node);
-        }
-        else if (node instanceof NamedTypeNode) {
-            this.visitNamedTypeNode(node);
-        }
-        else if (node instanceof FunctionTypeNode) {
-            this.visitFunctionTypeNode(node);
-        }
-        else if (node instanceof TypeName) {
-            this.visitTypeName(node);
-        }
-        else if (node instanceof TypeParameterNode) {
-            this.visitTypeParameter(node);
-        }
-        else if (node instanceof IdentifierExpression) {
-            this.visitIdentifierExpression(node);
-        }
-        else if (node instanceof AssertionExpression) {
-            this.visitAssertionExpression(node);
-        }
-        else if (node instanceof BinaryExpression) {
-            this.visitBinaryExpression(node);
-        }
-        else if (node instanceof CallExpression) {
-            this.visitCallExpression(node);
-        }
-        else if (node instanceof ClassExpression) {
-            this.visitClassExpression(node);
-        }
-        else if (node instanceof CommaExpression) {
-            this.visitCommaExpression(node);
-        }
-        else if (node instanceof ElementAccessExpression) {
-            this.visitElementAccessExpression(node);
-        }
-        else if (node instanceof FunctionExpression) {
-            this.visitFunctionExpression(node);
-        }
-        else if (node instanceof InstanceOfExpression) {
-            this.visitInstanceOfExpression(node);
-        }
-        else if (node instanceof LiteralExpression) {
-            this.visitLiteralExpression(node);
-        }
-        else if (node instanceof NewExpression) {
-            this.visitNewExpression(node);
-        }
-        else if (node instanceof ParenthesizedExpression) {
-            this.visitParenthesizedExpression(node);
-        }
-        else if (node instanceof PropertyAccessExpression) {
-            this.visitPropertyAccessExpression(node);
-        }
-        else if (node instanceof TernaryExpression) {
-            this.visitTernaryExpression(node);
-        }
-        else if (node instanceof UnaryPostfixExpression) {
-            this.visitUnaryPostfixExpression(node);
-        }
-        else if (node instanceof UnaryPrefixExpression) {
-            this.visitUnaryPrefixExpression(node);
-        }
-        else if (node instanceof BlockStatement) {
-            this.visitBlockStatement(node);
-        }
-        else if (node instanceof BreakStatement) {
-            this.visitBreakStatement(node);
-        }
-        else if (node instanceof ContinueStatement) {
-            this.visitContinueStatement(node);
-        }
-        else if (node instanceof DoStatement) {
-            this.visitDoStatement(node);
-        }
-        else if (node instanceof EmptyStatement) {
-            this.visitEmptyStatement(node);
-        }
-        else if (node instanceof ExportStatement) {
-            this.visitExportStatement(node);
-        }
-        else if (node instanceof ExportDefaultStatement) {
-            this.visitExportDefaultStatement(node);
-        }
-        else if (node instanceof ExportImportStatement) {
-            this.visitExportImportStatement(node);
-        }
-        else if (node instanceof ExpressionStatement) {
-            this.visitExpressionStatement(node);
-        }
-        else if (node instanceof ForStatement) {
-            this.visitForStatement(node);
-        }
-        else if (node instanceof IfStatement) {
-            this.visitIfStatement(node);
-        }
-        else if (node instanceof ImportStatement) {
-            this.visitImportStatement(node);
-        }
-        else if (node instanceof ReturnStatement) {
-            this.visitReturnStatement(node);
-        }
-        else if (node instanceof SwitchStatement) {
-            this.visitSwitchStatement(node);
-        }
-        else if (node instanceof ThrowStatement) {
-            this.visitThrowStatement(node);
-        }
-        else if (node instanceof TryStatement) {
-            this.visitTryStatement(node);
-        }
-        else if (node instanceof VariableStatement) {
-            this.visitVariableStatement(node);
-        }
-        else if (node instanceof WhileStatement) {
-            this.visitWhileStatement(node);
-        }
-        else if (node instanceof ClassDeclaration) {
-            this.visitClassDeclaration(node);
-        }
-        else if (node instanceof EnumDeclaration) {
-            this.visitEnumDeclaration(node);
-        }
-        else if (node instanceof EnumValueDeclaration) {
-            this.visitEnumValueDeclaration(node);
-        }
-        else if (node instanceof FieldDeclaration) {
-            this.visitFieldDeclaration(node);
-        }
-        else if (node instanceof FunctionDeclaration) {
-            this.visitFunctionDeclaration(node);
-        }
-        else if (node instanceof ImportDeclaration) {
-            this.visitImportDeclaration(node);
-        }
-        else if (node instanceof InterfaceDeclaration) {
-            this.visitInterfaceDeclaration(node);
-        }
-        else if (node instanceof MethodDeclaration) {
-            this.visitMethodDeclaration(node);
-        }
-        else if (node instanceof NamespaceDeclaration) {
-            this.visitNamespaceDeclaration(node);
-        }
-        else if (node instanceof TypeDeclaration) {
-            this.visitTypeDeclaration(node);
-        }
-        else if (node instanceof VariableDeclaration) {
-            this.visitVariableDeclaration(node);
-        }
-        else if (node instanceof DecoratorNode) {
-            this.visitDecoratorNode(node);
-        }
-        else if (node instanceof ExportMember) {
-            this.visitExportMember(node);
-        }
-        else if (node instanceof ParameterNode) {
-            this.visitParameter(node);
-        }
-        else if (node instanceof SwitchCase) {
-            this.visitSwitchCase(node);
-        }
-        else if (node instanceof IndexSignatureNode) {
-            this.visitIndexSignature(node);
-        }
-        else {
-            throw new Error("Could not visit invalid type!");
-        }
-    }
-    visitSource(node) {
-        this.currentSource = node;
-        for (const stmt of node.statements) {
-            this.depth++;
-            this._visit(stmt);
-            this.depth--;
-        }
-        this.currentSource = null;
-    }
-    visitTypeNode(node) { }
-    visitTypeName(node) {
-        this.visit(node.identifier);
-        this.visit(node.next);
-    }
-    visitNamedTypeNode(node) {
-        this.visit(node.name);
-        this.visit(node.typeArguments);
-    }
-    visitFunctionTypeNode(node) {
-        this.visit(node.parameters);
-        this.visit(node.returnType);
-        this.visit(node.explicitThisType);
-    }
-    visitTypeParameter(node) {
-        this.visit(node.name);
-        this.visit(node.extendsType);
-        this.visit(node.defaultType);
-    }
-    visitIdentifierExpression(node) { }
-    visitArrayLiteralExpression(node) {
-        this.visit(node.elementExpressions);
-    }
-    visitObjectLiteralExpression(node) {
-        this.visit(node.names);
-        this.visit(node.values);
-    }
-    visitAssertionExpression(node) {
-        this.visit(node.toType);
-        this.visit(node.expression);
-    }
-    visitBinaryExpression(node) {
-        this.visit(node.left);
-        this.visit(node.right);
-    }
-    visitCallExpression(node) {
-        this.visit(node.expression);
-        this.visitArguments(node.typeArguments, node.args);
-    }
-    visitArguments(typeArguments, args) {
-        this.visit(typeArguments);
-        this.visit(args);
-    }
-    visitClassExpression(node) {
-        this.visit(node.declaration);
-    }
-    visitCommaExpression(node) {
-        this.visit(node.expressions);
-    }
-    visitElementAccessExpression(node) {
-        this.visit(node.elementExpression);
-        this.visit(node.expression);
-    }
-    visitFunctionExpression(node) {
-        this.visit(node.declaration);
-    }
-    visitLiteralExpression(node) {
-        if (node instanceof FloatLiteralExpression) {
-            this.visitFloatLiteralExpression(node);
-        }
-        else if (node instanceof IntegerLiteralExpression) {
-            this.visitIntegerLiteralExpression(node);
-        }
-        else if (node instanceof StringLiteralExpression) {
-            this.visitStringLiteralExpression(node);
-        }
-        else if (node instanceof TemplateLiteralExpression) {
-            this.visitTemplateLiteralExpression(node);
-        }
-        else if (node instanceof RegexpLiteralExpression) {
-            this.visitRegexpLiteralExpression(node);
-        }
-        else if (node instanceof ArrayLiteralExpression) {
-            this.visitArrayLiteralExpression(node);
-        }
-        else if (node instanceof ObjectLiteralExpression) {
-            this.visitObjectLiteralExpression(node);
-        }
-        else {
-            throw new Error("Invalid LiteralKind at visitLiteralExpression(): " + node.literalKind);
-        }
-    }
-    visitFloatLiteralExpression(node) { }
-    visitInstanceOfExpression(node) {
-        this.visit(node.expression);
-        this.visit(node.isType);
-    }
-    visitIntegerLiteralExpression(node) { }
-    visitStringLiteral(str, singleQuoted = false) { }
-    visitStringLiteralExpression(node) {
-        this.visitStringLiteral(node.value);
-    }
-    visitTemplateLiteralExpression(node) { }
-    visitRegexpLiteralExpression(node) { }
-    visitNewExpression(node) {
-        this.visit(node.typeArguments);
-        this.visitArguments(node.typeArguments, node.args);
-        this.visit(node.args);
-    }
-    visitParenthesizedExpression(node) {
-        this.visit(node.expression);
-    }
-    visitPropertyAccessExpression(node) {
-        this.visit(node.property);
-        this.visit(node.expression);
-    }
-    visitTernaryExpression(node) {
-        this.visit(node.condition);
-        this.visit(node.ifThen);
-        this.visit(node.ifElse);
-    }
-    visitUnaryExpression(node) {
-        this.visit(node.operand);
-    }
-    visitUnaryPostfixExpression(node) {
-        this.visit(node.operand);
-    }
-    visitUnaryPrefixExpression(node) {
-        this.visit(node.operand);
-    }
-    visitSuperExpression(node) { }
-    visitFalseExpression(node) { }
-    visitTrueExpression(node) { }
-    visitThisExpression(node) { }
-    visitNullExperssion(node) { }
-    visitConstructorExpression(node) { }
-    visitNodeAndTerminate(statement) { }
-    visitBlockStatement(node) {
-        this.depth++;
-        this.visit(node.statements);
-        this.depth--;
-    }
-    visitBreakStatement(node) {
-        this.visit(node.label);
-    }
-    visitContinueStatement(node) {
-        this.visit(node.label);
-    }
-    visitClassDeclaration(node, isDefault = false) {
-        this.visit(node.name);
-        this.depth++;
-        this.visit(node.decorators);
-        if (node.isGeneric ? node.typeParameters != null : node.typeParameters == null) {
-            this.visit(node.typeParameters);
-            this.visit(node.extendsType);
-            this.visit(node.implementsTypes);
-            this.visit(node.members);
-            this.depth--;
-        }
-        else {
-            throw new Error("Expected to type parameters to match class declaration, but found type mismatch instead!");
-        }
-    }
-    visitDoStatement(node) {
-        this.visit(node.condition);
-        this.visit(node.body);
-    }
-    visitEmptyStatement(node) { }
-    visitEnumDeclaration(node, isDefault = false) {
-        this.visit(node.name);
-        this.visit(node.decorators);
-        this.visit(node.values);
-    }
-    visitEnumValueDeclaration(node) {
-        this.visit(node.name);
-        this.visit(node.initializer);
-    }
-    visitExportImportStatement(node) {
-        this.visit(node.name);
-        this.visit(node.externalName);
-    }
-    visitExportMember(node) {
-        this.visit(node.localName);
-        this.visit(node.exportedName);
-    }
-    visitExportStatement(node) {
-        this.visit(node.path);
-        this.visit(node.members);
-    }
-    visitExportDefaultStatement(node) {
-        this.visit(node.declaration);
-    }
-    visitExpressionStatement(node) {
-        this.visit(node.expression);
-    }
-    visitFieldDeclaration(node) {
-        this.visit(node.name);
-        this.visit(node.type);
-        this.visit(node.initializer);
-        this.visit(node.decorators);
-    }
-    visitForStatement(node) {
-        this.visit(node.initializer);
-        this.visit(node.condition);
-        this.visit(node.incrementor);
-        this.visit(node.body);
-    }
-    visitFunctionDeclaration(node, isDefault = false) {
-        this.visit(node.name);
-        this.visit(node.decorators);
-        this.visit(node.typeParameters);
-        this.visit(node.signature);
-        this.depth++;
-        this.visit(node.body);
-        this.depth--;
-    }
-    visitIfStatement(node) {
-        this.visit(node.condition);
-        this.visit(node.ifTrue);
-        this.visit(node.ifFalse);
-    }
-    visitImportDeclaration(node) {
-        this.visit(node.foreignName);
-        this.visit(node.name);
-        this.visit(node.decorators);
-    }
-    visitImportStatement(node) {
-        this.visit(node.namespaceName);
-        this.visit(node.declarations);
-    }
-    visitIndexSignature(node) {
-        this.visit(node.keyType);
-        this.visit(node.valueType);
-    }
-    visitInterfaceDeclaration(node, isDefault = false) {
-        this.visit(node.name);
-        this.visit(node.typeParameters);
-        this.visit(node.implementsTypes);
-        this.visit(node.extendsType);
-        this.depth++;
-        this.visit(node.members);
-        this.depth--;
-    }
-    visitMethodDeclaration(node) {
-        this.visit(node.name);
-        this.visit(node.typeParameters);
-        this.visit(node.signature);
-        this.visit(node.decorators);
-        this.depth++;
-        this.visit(node.body);
-        this.depth--;
-    }
-    visitNamespaceDeclaration(node, isDefault = false) {
-        this.visit(node.name);
-        this.visit(node.decorators);
-        this.visit(node.members);
-    }
-    visitReturnStatement(node) {
-        this.visit(node.value);
-    }
-    visitSwitchCase(node) {
-        this.visit(node.label);
-        this.visit(node.statements);
-    }
-    visitSwitchStatement(node) {
-        this.visit(node.condition);
-        this.depth++;
-        this.visit(node.cases);
-        this.depth--;
-    }
-    visitThrowStatement(node) {
-        this.visit(node.value);
-    }
-    visitTryStatement(node) {
-        this.visit(node.bodyStatements);
-        this.visit(node.catchVariable);
-        this.visit(node.catchStatements);
-        this.visit(node.finallyStatements);
-    }
-    visitTypeDeclaration(node) {
-        this.visit(node.name);
-        this.visit(node.decorators);
-        this.visit(node.type);
-        this.visit(node.typeParameters);
-    }
-    visitVariableDeclaration(node) {
-        this.visit(node.name);
-        this.visit(node.type);
-        this.visit(node.initializer);
-    }
-    visitVariableStatement(node) {
-        this.visit(node.decorators);
-        this.visit(node.declarations);
-    }
-    visitWhileStatement(node) {
-        this.visit(node.condition);
-        this.depth++;
-        this.visit(node.body);
-        this.depth--;
-    }
-    visitVoidStatement(node) { }
-    visitComment(node) { }
-    visitDecoratorNode(node) {
-        this.visit(node.name);
-        this.visit(node.args);
-    }
-    visitParameter(node) {
-        this.visit(node.name);
-        this.visit(node.implicitFieldDeclaration);
-        this.visit(node.initializer);
-        this.visit(node.type);
-    }
-}