json-as 1.1.16 → 1.1.18

package/transform/src/index.ts

@@ -4,22 +4,20 @@ import { Visitor } from "./visitor.js";
 import { isStdlib, removeExtension, SimpleParser, toString } from "./util.js";
 import * as path from "path";
 import { fileURLToPath } from "url";
-import { Property, PropertyFlags, Schema, Src } from "./types.js";
-import { getClass, getImportedClass } from "./linkers/classes.js";
-import { existsSync, writeFileSync } from "fs";
+import { Property, PropertyFlags, Schema, Src, SourceSet } from "./types.js";
+import { readFileSync, writeFileSync } from "fs";
 import { CustomTransform } from "./linkers/custom.js";
 
 let indent = "  ";
 
 let id = 0;
 
-const WRITE = process.env["JSON_WRITE"];
-const rawValue = process.env["JSON_DEBUG"];
+const WRITE = process.env["JSON_WRITE"]?.trim();
+const rawValue = process.env["JSON_DEBUG"]?.trim();
 
 const DEBUG = rawValue === "true" ? 1 : rawValue === "false" || rawValue === "" ? 0 : isNaN(Number(rawValue)) ? 0 : Number(rawValue);
 
 const STRICT = process.env["JSON_STRICT"] && process.env["JSON_STRICT"] == "true";
-
 export class JSONTransform extends Visitor {
   static SN: JSONTransform = new JSONTransform();
 
@@ -28,10 +26,8 @@ export class JSONTransform extends Visitor {
   public parser!: Parser;
   public schemas: Map<string, Schema[]> = new Map<string, Schema[]>();
   public schema!: Schema;
-  public src!: Src;
-  public sources: Map<string, Src> = new Map<string, Src>();
+  public sources: SourceSet = new SourceSet();
   public imports: ImportStatement[] = [];
-
   public simdStatements: string[] = [];
 
   private visitedClasses: Set<string> = new Set<string>();
@@ -47,6 +43,7 @@ export class JSONTransform extends Visitor {
       throw new Error("Class " + node.name.text + " is missing an @json or @serializable decorator in " + node.range.source.internalPath);
     this.visitClassDeclaration(node);
   }
+
   visitClassDeclaration(node: ClassDeclaration): void {
     if (!node.decorators?.length) return;
 
@@ -58,13 +55,11 @@ export class JSONTransform extends Visitor {
     )
       return;
 
-    const source = node.range.source;
-    if (!this.sources.has(source.internalPath)) {
-      this.src = new Src(source);
-      this.sources.set(source.internalPath, this.src);
-    } else this.src = this.sources.get(source.internalPath);
+    const source = this.sources.get(node.range.source);
 
-    if (this.visitedClasses.has(source.internalPath + node.name.text)) return;
+    const fullClassPath = source.getFullPath(node);
+
+    if (this.visitedClasses.has(fullClassPath)) return;
     if (!this.schemas.has(source.internalPath)) this.schemas.set(source.internalPath, []);
 
     const members: FieldDeclaration[] = [...(node.members.filter((v) => v.kind === NodeKind.FieldDeclaration && v.flags !== CommonFlags.Static && v.flags !== CommonFlags.Private && v.flags !== CommonFlags.Protected && !v.decorators?.some((decorator) => (<IdentifierExpression>decorator.name).text === "omit")) as FieldDeclaration[])];
@@ -73,10 +68,11 @@ export class JSONTransform extends Visitor {
 
     const schema = new Schema();
     schema.node = node;
-    schema.name = node.name.text;
+    schema.name = source.getQualifiedName(node);
 
     if (node.extendsType) {
-      const extendsName = node.extendsType?.name.identifier.text;
+      const extendsName = source.resolveExtendsName(node);
+
       if (!schema.parent) {
         const depSearch = schema.deps.find((v) => v.name == extendsName);
         if (depSearch) {
@@ -84,31 +80,32 @@ export class JSONTransform extends Visitor {
           if (!schema.deps.some((v) => v.name == depSearch.name)) schema.deps.push(depSearch);
           schema.parent = depSearch;
         } else {
-          const internalSearch = getClass(extendsName, source);
+          const internalSearch = source.getClass(extendsName);
           if (internalSearch) {
             if (DEBUG > 0) console.log("Found " + extendsName + " internally from " + source.internalPath);
-            if (!this.visitedClasses.has(internalSearch.range.source.internalPath + internalSearch.name.text)) {
+            if (!this.visitedClasses.has(source.getFullPath(internalSearch))) {
               this.visitClassDeclarationRef(internalSearch);
               this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
               this.visitClassDeclaration(node);
               return;
             }
-            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == internalSearch.name.text);
+            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == extendsName);
             if (!schem) throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
             schema.deps.push(schem);
             schema.parent = schem;
           } else {
-            const externalSearch = getImportedClass(extendsName, source, this.parser);
+            const externalSearch = source.getImportedClass(extendsName, this.parser);
             if (externalSearch) {
               if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
-              if (!this.visitedClasses.has(externalSearch.range.source.internalPath + externalSearch.name.text)) {
+              const externalSource = this.sources.get(externalSearch.range.source);
+              if (!this.visitedClasses.has(externalSource.getFullPath(externalSearch))) {
                 this.visitClassDeclarationRef(externalSearch);
-                this.schemas.get(externalSearch.range.source.internalPath).push(this.schema);
+                this.schemas.get(externalSource.internalPath).push(this.schema);
                 this.visitClassDeclaration(node);
                 return;
               }
-              const schem = this.schemas.get(externalSearch.range.source.internalPath)?.find((s) => s.name == externalSearch.name.text);
-              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSearch.range.source.internalPath);
+              const schem = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == extendsName);
+              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
               schema.deps.push(schem);
               schema.parent = schem;
             }
@@ -127,7 +124,7 @@ export class JSONTransform extends Visitor {
 
     const getUnknownTypes = (type: string, types: string[] = []): string[] => {
       type = stripNull(type);
-      type = this.src.aliases.find((v) => stripNull(v.name) == type)?.getBaseType() || type;
+      type = source.aliases.find((v) => stripNull(v.name) == type)?.getBaseType() || type;
       if (type.startsWith("Array<")) {
         return getUnknownTypes(type.slice(6, -1));
       } else if (type.startsWith("Map<")) {
@@ -158,35 +155,36 @@ export class JSONTransform extends Visitor {
             schema.deps.push(depSearch);
           }
         } else {
-          const internalSearch = getClass(unknownType, source);
+          const internalSearch = source.getClass(unknownType);
           if (internalSearch) {
             if (DEBUG > 0) console.log("Found " + unknownType + " internally from " + source.internalPath);
-            if (!this.visitedClasses.has(internalSearch.range.source.internalPath + internalSearch.name.text)) {
+            if (!this.visitedClasses.has(source.getFullPath(internalSearch))) {
               this.visitClassDeclarationRef(internalSearch);
-              const internalSchema = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == internalSearch.name.text);
+              const internalSchema = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == unknownType);
               // if (internalSchema.custom) mem.custom = true;
               schema.deps.push(internalSchema);
               this.schemas.get(internalSearch.range.source.internalPath).push(this.schema);
               this.visitClassDeclaration(node);
               return;
             }
-            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == internalSearch.name.text);
+            const schem = this.schemas.get(internalSearch.range.source.internalPath)?.find((s) => s.name == unknownType);
             if (!schem) throw new Error("Could not find schema for " + internalSearch.name.text + " in " + internalSearch.range.source.internalPath);
             schema.deps.push(schem);
           } else {
-            const externalSearch = getImportedClass(unknownType, source, this.parser);
+            const externalSearch = source.getImportedClass(unknownType, this.parser);
             if (externalSearch) {
               if (DEBUG > 0) console.log("Found " + externalSearch.name.text + " externally from " + source.internalPath);
-              if (!this.visitedClasses.has(externalSearch.range.source.internalPath + externalSearch.name.text)) {
+              const externalSource = this.sources.get(externalSearch.range.source);
+              if (!this.visitedClasses.has(externalSource.getFullPath(externalSearch))) {
                 this.visitClassDeclarationRef(externalSearch);
-                const externalSchema = this.schemas.get(externalSearch.range.source.internalPath)?.find((s) => s.name == externalSearch.name.text);
+                const externalSchema = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == unknownType);
                 schema.deps.push(externalSchema);
-                this.schemas.get(externalSearch.range.source.internalPath).push(this.schema);
+                this.schemas.get(externalSource.internalPath).push(this.schema);
                 this.visitClassDeclaration(node);
                 return;
               }
-              const schem = this.schemas.get(externalSearch.range.source.internalPath)?.find((s) => s.name == externalSearch.name.text);
-              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSearch.range.source.internalPath);
+              const schem = this.schemas.get(externalSource.internalPath)?.find((s) => s.name == unknownType);
+              if (!schem) throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
               schema.deps.push(schem);
             }
           }
@@ -196,7 +194,7 @@ export class JSONTransform extends Visitor {
 
     this.schemas.get(source.internalPath).push(schema);
     this.schema = schema;
-    this.visitedClasses.add(source.internalPath + node.name.text);
+    this.visitedClasses.add(fullClassPath);
 
     let SERIALIZE = "__SERIALIZE(ptr: usize): void {\n";
     let INITIALIZE = "@inline __INITIALIZE(): this {\n";
@@ -258,7 +256,7 @@ export class JSONTransform extends Visitor {
     for (const member of members) {
       if (!member.type) throwError("Fields must be strongly typed", node.range);
       let type = toString(member.type!);
-      type = this.src.aliases.find((v) => stripNull(v.name) == stripNull(type))?.getBaseType() || type;
+      type = source.aliases.find((v) => stripNull(v.name) == stripNull(type))?.getBaseType() || type;
 
       const name = member.name;
       const value = member.initializer ? toString(member.initializer!) : null;
@@ -335,8 +333,8 @@ export class JSONTransform extends Visitor {
       const realName = member.name;
       const isLast = i == this.schema.members.length - 1;
 
-      if (member.value && member.type == stripNull(member.type)) {
-        if (!(member.value == "null" || member.value == "0" || member.value == "0.0" || member.value == "false")) {
+      if (member.value) {
+        if (member.value != "null" && member.value != "0" && member.value != "0.0" && member.value != "false") {
           INITIALIZE += `  store<${member.type}>(changetype<usize>(this), ${member.value}, offsetof<this>(${JSON.stringify(member.name)}));\n`;
         }
       } else if (member.generic) {
@@ -1060,7 +1058,7 @@ export class JSONTransform extends Visitor {
   generateEmptyMethods(node: ClassDeclaration): void {
     let SERIALIZE_EMPTY = "@inline __SERIALIZE(ptr: usize): void {\n  bs.proposeSize(4);\n  store<u32>(bs.offset, 8192123);\n  bs.offset += 4;\n}";
     let INITIALIZE_EMPTY = "@inline __INITIALIZE(): this {\n  return this;\n}";
-    let DESERIALIZE_EMPTY = "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n  return this;\n}";
+    let DESERIALIZE_EMPTY = "@inline __DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n  return out;\n}";
 
     if (DEBUG > 0) {
       console.log(SERIALIZE_EMPTY);
@@ -1115,12 +1113,20 @@ export class JSONTransform extends Visitor {
     this.baseCWD = this.baseCWD.replaceAll("/", path.sep);
 
     const baseDir = path.resolve(fileURLToPath(import.meta.url), "..", "..", "..");
-    const pkgPath = path.join(this.baseCWD, "node_modules");
     let fromPath = node.range.source.normalizedPath.replaceAll("/", path.sep);
 
+    const isLib = path.dirname(baseDir).endsWith("node_modules");
+
+    if (!isLib && !this.parser.sources.some((s) => s.normalizedPath.startsWith("assembly/index"))) {
+      const newPath = "./assembly/index.ts";
+      this.parser.parseFile(readFileSync(path.join(...newPath.split("/"))).toString(), newPath, false);
+    } else if (isLib && !this.parser.sources.some((s) => s.normalizedPath.startsWith("~lib/json-as/assembly/index"))) {
+      const newPath = "~lib/json-as/assembly/index.ts";
+      this.parser.parseFile(readFileSync(path.join(...newPath.split("/"))).toString(), newPath, false);
+    }
+
     // console.log("baseCWD", this.baseCWD);
     // console.log("baseDir", baseDir);
-    // console.log("pkgPath: ", pkgPath);
 
     fromPath = fromPath.startsWith("~lib") ? fromPath.slice(5) : path.join(this.baseCWD, fromPath);
 
@@ -1131,8 +1137,8 @@ export class JSONTransform extends Visitor {
 
     let baseRel = path.posix.join(...path.relative(path.dirname(fromPath), path.join(baseDir)).split(path.sep));
 
-    if (baseRel.endsWith("node_modules/json-as")) {
-      baseRel = "json-as" + baseRel.slice(baseRel.indexOf("node_modules/json-as") + 20);
+    if (baseRel.endsWith("json-as")) {
+      baseRel = "json-as" + baseRel.slice(baseRel.indexOf("json-as") + 7);
     } else if (!baseRel.startsWith(".") && !baseRel.startsWith("/") && !baseRel.startsWith("json-as")) {
       baseRel = "./" + baseRel;
     }
@@ -1400,15 +1406,6 @@ function isBoolean(type: string): boolean {
   return type == "bool" || type == "boolean";
 }
 
-function isStruct(type: string): boolean {
-  type = stripNull(type);
-  const schema = JSONTransform.SN.schema;
-  if (schema.name == type) return true;
-  const depSearch = schema.deps.some((v) => v.name == type);
-  if (depSearch) return true;
-  return false;
-}
-
 function isString(type: string) {
   return stripNull(type) == "string" || stripNull(type) == "String";
 }

package/transform/src/types.ts

@@ -1,6 +1,6 @@
-import { ClassDeclaration, Expression, FieldDeclaration, Source } from "assemblyscript/dist/assemblyscript.js";
+import { ClassDeclaration, Expression, FieldDeclaration, Source, NodeKind, Node, NamespaceDeclaration, DeclarationStatement, TypeName, Parser, ImportStatement, CommonFlags } from "assemblyscript/dist/assemblyscript.js";
 import { TypeAlias } from "./linkers/alias.js";
-import { JSONTransform, stripNull } from "./index.js";
+import { stripNull } from "./index.js";
 
 export enum PropertyFlags {
   OmitNull,
@@ -75,14 +75,192 @@ export class Schema {
   }
 }
 
+export class SourceSet {
+  private sources: Record<string, Src> = {};
+
+  /**
+   * Get a stored source from the set, or create a new one and store it if it
+   * didn't exist.
+   * @param source AssemblyScript Source
+   * @returns Source object
+   */
+  get(source: Source): Src {
+    let src = this.sources[source.internalPath];
+    if (!src) {
+      src = new Src(source, this);
+      this.sources[source.internalPath] = src;
+    }
+    return src;
+  }
+}
+
 export class Src {
   public internalPath: string;
+  public normalizedPath: string;
   public schemas: Schema[];
   public aliases: TypeAlias[];
-  public imports: Schema[];
   public exports: Schema[];
-  constructor(source: Source) {
+  private nodeMap: Map<Node, NamespaceDeclaration[]> = new Map<Node, NamespaceDeclaration[]>();
+  private classes: Record<string, ClassDeclaration> = {};
+  private imports: ImportStatement[] = [];
+
+  constructor(
+    source: Source,
+    private sourceSet: SourceSet,
+  ) {
     this.internalPath = source.internalPath;
+    this.normalizedPath = source.normalizedPath;
     this.aliases = TypeAlias.getAliases(source);
+    this.traverse(source.statements, []);
+  }
+
+  /**
+   * Traverse source nodes and finds all classes and imports, and which namespaces they exist under.
+   * @param nodes Nodes to traverse.
+   * @param path The current path of namespace declarations leading to the nodes.
+   */
+  private traverse(nodes: Node[], path: NamespaceDeclaration[]) {
+    for (let node of nodes) {
+      switch (node.kind) {
+        case NodeKind.NamespaceDeclaration:
+          const namespaceDeclaration = node as NamespaceDeclaration;
+          this.traverse(namespaceDeclaration.members, [...path, namespaceDeclaration]);
+          break;
+        case NodeKind.ClassDeclaration:
+          const classDeclaration = node as ClassDeclaration;
+          this.classes[this.qualifiedName(classDeclaration, path)] = classDeclaration;
+          break;
+        case NodeKind.Import:
+          const importStatement = node as ImportStatement;
+          this.imports.push(importStatement);
+          break;
+      }
+      this.nodeMap.set(node, path);
+    }
+  }
+
+  /**
+   * Get the qualified name (eg. "Namespace.BaseObject") for a class.
+   * @param node Class declaration.
+   * @returns Qualified name
+   */
+  getQualifiedName(node: DeclarationStatement): string {
+    return this.qualifiedName(node, this.nodeMap.get(node));
+  }
+
+  /**
+   * Get a class declaration by its qualified name.
+   * @param qualifiedName Qualified named (eg. "Namespace.BaseObject")
+   * @returns Class declaration or null if not found.
+   */
+  getClass(qualifiedName: string): ClassDeclaration | null {
+    return this.classes[qualifiedName] || null;
+  }
+
+  /**
+   * Get imported class from other sources in the parser.
+   * @param qualifiedName Qualified name of class.
+   * @param parser AssemblyScript parser.
+   * @returns Class declaration or null if not found.
+   */
+  getImportedClass(qualifiedName: string, parser: Parser): ClassDeclaration | null {
+    for (const stmt of this.imports) {
+      const externalSource = parser.sources.filter((src) => src.internalPath != this.internalPath).find((src) => src.internalPath == stmt.internalPath);
+      if (!externalSource) continue;
+
+      const source = this.sourceSet.get(externalSource);
+      const classDeclaration = source.getClass(qualifiedName);
+      if (classDeclaration && classDeclaration.flags & CommonFlags.Export) {
+        return classDeclaration;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Gets a unique path string to the node by combining the internalPath with
+   * the qualified name of the node.
+   * @param node DeclarationStatement
+   */
+  getFullPath(node: DeclarationStatement): string {
+    return this.internalPath + "/" + this.getQualifiedName(node);
+  }
+
+  /**
+   * Resolved the qualified name of the extended class for a class
+   * declaration.
+   * @param classDeclaration Class declaration that extends another class.
+   * @returns Qualified name of the extended class, or empty string if not extending any class.
+   */
+  resolveExtendsName(classDeclaration: ClassDeclaration): string {
+    const parents = this.nodeMap.get(classDeclaration);
+    if (!classDeclaration.extendsType || !parents) {
+      return "";
+    }
+
+    const name = classDeclaration.extendsType.name.identifier.text;
+    const extendsName = this.getIdentifier(classDeclaration.extendsType.name);
+
+    // Reverse walk to find first class or namespace that matches the first part
+    // of type name.
+    for (let i = parents.length - 1; i >= 0; i--) {
+      const parent = parents[i];
+      for (let node of parent.members) {
+        if (name == this.getNamespaceOrClassName(node)) {
+          // Add namespace path to the extendsName.
+          return (
+            parents
+              .slice(0, i + 1)
+              .map((p) => p.name.text)
+              .join(".") +
+            "." +
+            extendsName
+          );
+        }
+      }
+    }
+    // No matching class or namespace found. Just use the extendsName.
+    return extendsName;
+  }
+
+  /**
+   * Get the qualified name (eg "Namespace.BaseObject") of a class.
+   * @param node Class declaration.
+   * @param parents Array of namespace parents.
+   * @returns Qualified name
+   */
+  private qualifiedName(node: DeclarationStatement, parents: NamespaceDeclaration[]): string {
+    return parents?.length ? parents.map((p) => p.name.text).join(".") + "." + node.name.text : node.name.text;
+  }
+
+  /**
+   * Checks if the node is either a namespace or class, and returns the simple
+   * name of the node.
+   * @param node Node to check
+   * @returns Name of namespace or class, or empty string if other type of node.
+   */
+  private getNamespaceOrClassName(node: Node): string {
+    switch (node.kind) {
+      case NodeKind.NamespaceDeclaration:
+        return (node as DeclarationStatement).name.text;
+      case NodeKind.ClassDeclaration:
+        return (node as DeclarationStatement).name.text;
+    }
+    return "";
+  }
+
+  /**
+   * Get the full name (eg. "Namespace.Base") of a type name such as an
+   * extendedType.
+   * @param typeName Type name
+   * @returns Full name
+   */
+  private getIdentifier(typeName: TypeName): string {
+    let names = [];
+    while (typeName) {
+      names.push(typeName.identifier.text);
+      typeName = typeName.next;
+    }
+    return names.join(".");
   }
 }

package/transform/src/linkers/classes.ts

@@ -1,50 +0,0 @@
-import { ClassDeclaration, CommonFlags, NodeKind, Parser, Source } from "assemblyscript/dist/assemblyscript.js";
-import { Visitor } from "../visitor.js";
-import { getImports } from "./imports.js";
-
-export function getImportedClass(name: string, source: Source, parser: Parser): ClassDeclaration | null {
-  for (const stmt of getImports(source)) {
-    const externalSource = parser.sources.filter((src) => src.internalPath != source.internalPath).find((src) => src.internalPath == stmt.internalPath);
-    if (!externalSource) continue;
-
-    const classDeclaration = ClassGetter.getClass(name, externalSource);
-    if (!classDeclaration) continue;
-    if (!(classDeclaration.flags & CommonFlags.Export)) continue;
-    return classDeclaration;
-  }
-  return null;
-}
-
-class ClassGetter extends Visitor {
-  static SN: ClassGetter = new ClassGetter();
-
-  private classes: ClassDeclaration[] = [];
-
-  visitClassDeclaration(node: ClassDeclaration): void {
-    this.classes.push(node);
-  }
-
-  // visitTypeName(node: TypeName, ref?: Node | null): void {}
-  // visitParameter(node: ParameterNode, ref?: Node | null): void {}
-  // visitFunctionTypeNode(node: FunctionTypeNode, ref?: Node | null): void {}
-  // visitNamedTypeNode(node: NamedTypeNode, ref?: Node | null): void {}
-
-  static getClass(name: string, source: Source): ClassDeclaration | null {
-    return ClassGetter.getClasses(source).find((c) => c.name.text == name) || null;
-  }
-
-  static getClasses(source: Source): ClassDeclaration[] {
-    // ClassGetter.SN.classes = [];
-    // ClassGetter.SN.visit(source);
-    // return ClassGetter.SN.classes;
-    return source.statements.filter((stmt) => stmt.kind == NodeKind.ClassDeclaration) as ClassDeclaration[];
-  }
-}
-
-export function getClasses(source: Source): ClassDeclaration[] {
-  return ClassGetter.getClasses(source);
-}
-
-export function getClass(name: string, source: Source): ClassDeclaration | null {
-  return ClassGetter.getClass(name, source);
-}