json-as 1.1.16 → 1.1.18

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change Log
 
+## 2025-06-30 - 1.1.18
+
+- fix: [#150](https://github.com/JairusSW/json-as/issues/150)
+
+## 2025-06-17 - 1.1.17
+
+- fix: add support for classes within namespaces [#147](https://github.com/JairusSW/json-as/pull/147)
+
 ## 2025-06-12 - 1.1.16
 
 - tests: properly support nulls (in testing lib)

package/README.md

@@ -6,7 +6,7 @@
 ██   ██      ██ ██    ██ ██  ██ ██       ██   ██      ██
  █████  ███████  ██████  ██   ████       ██   ██ ███████
  </span>
-    AssemblyScript - v1.1.16
+    AssemblyScript - v1.1.18
   </pre>
 </h6>
 

package/assembly/__tests__/namespace.spec.ts

@@ -0,0 +1,63 @@
+import { JSON } from "..";
+import { describe, expect } from "./lib";
+
+describe("Should serialize namespaced derived structs", () => {
+  const obj: Namespace.DerivedObject = { a: "foo", b: "bar" };
+  expect(JSON.stringify(obj)).toBe(`{"a":"foo","b":"bar"}`);
+});
+
+describe("Should serialize namespaced derived structs with nested object", () => {
+  const bar: Namespace.Bar = { value: "baz" };
+  const obj: Namespace.DerivedObjectWithNestedObject = { a: "foo", b: "bar", c: bar };
+  expect(JSON.stringify(obj)).toBe(`{"a":"foo","b":"bar","c":{"value":"baz"}}`);
+});
+
+describe("Should deserialize namespaced object with alias property", () => {
+  expect(JSON.stringify(JSON.parse<Namespace.ObjectWithAliasProperty>(`{"a":"foo","value":42}`))).toBe(`{"a":"foo","value":42}`);
+});
+
+describe("Should deserialize namespaced derived structs", () => {
+  expect(JSON.stringify(JSON.parse<Namespace.DerivedObject>(`{"a":"foo","b":"bar"}`))).toBe(`{"a":"foo","b":"bar"}`);
+  expect(JSON.stringify(JSON.parse<Namespace.DerivedObject>(`{"b":"bar","a":"foo"}`))).toBe(`{"a":"foo","b":"bar"}`);
+});
+
+describe("Should deserialize namespaced derived structs with nested object", () => {
+  expect(JSON.stringify(JSON.parse<Namespace.DerivedObjectWithNestedObject>(`{"a":"foo","b":"bar","c":{"value":"baz"}}`))).toBe(`{"a":"foo","b":"bar","c":{"value":"baz"}}`);
+  expect(JSON.stringify(JSON.parse<Namespace.DerivedObjectWithNestedObject>(`{"c":{"value":"baz"},"a":"foo","b":"bar"}`))).toBe(`{"a":"foo","b":"bar","c":{"value":"baz"}}`);
+});
+
+type NumberAlias = i64;
+
+namespace Namespace {
+
+  @json
+  export class Base {
+    a: string = "";
+  }
+
+
+  @json
+  export class Bar {
+    value: string = "";
+  }
+
+
+  @json
+  export class ObjectWithAliasProperty {
+    a: string = "";
+    value: NumberAlias = 0;
+  }
+
+
+  @json
+  export class DerivedObject extends Base {
+    b: string = "";
+  }
+
+
+  @json
+  export class DerivedObjectWithNestedObject extends Base {
+    b: string = "";
+    c: Bar = new Bar();
+  }
+}

package/assembly/index.ts

@@ -605,7 +605,7 @@ export namespace JSON {
       if (isDefined(type.__DESERIALIZE)) {
         const out = changetype<nonnull<T>>(dst || __new(offsetof<nonnull<T>>(), idof<nonnull<T>>()));
         // @ts-ignore: Defined by transform
-        if (isDefined(type.__INITIALIZE)) out.__INITIALIZE();
+        if (isNullable<T>() && isDefined(type.__INITIALIZE)) out.__INITIALIZE();
         // @ts-ignore: Defined by transform
         return out.__DESERIALIZE(srcStart, srcEnd, out);
       } else if (type instanceof Map) {

package/assembly/test.tmp.ts

@@ -1,5 +1,5 @@
+import { JSON } from "../assembly/index";
 import { bs } from "../lib/as-bs";
-import { JSON } from ".";
 
 @json
 class Vec3 {
@@ -214,13 +214,10 @@ class Player {
 
   @omitif((self: this): boolean => self.age < 18)
   age!: i32;
-
-  @omitnull()
   pos!: Vec3 | null;
   isVerified!: boolean;
   __SERIALIZE(ptr: usize): void {
-    bs.proposeSize(160);
-    let block: usize = 0;
+    bs.proposeSize(158);
     store<u16>(bs.offset, 123, 0);
     bs.offset += 2;
     if (!((self: this): boolean => self.age < 18)(this)) {
@@ -231,14 +228,6 @@ class Player {
       store<u16>(bs.offset, 44, 0);
       bs.offset += 2;
     }
-    if ((block = load<usize>(ptr, offsetof<this>("pos"))) !== 0) {
-      store<u64>(bs.offset, 32370099070435362, 0);
-      store<u32>(bs.offset, 3801122, 8);
-      bs.offset += 12;
-      JSON.__serialize<Vec3 | null>(load<Vec3 | null>(ptr, offsetof<this>("pos")));
-      store<u16>(bs.offset, 44, 0);
-      bs.offset += 2;
-    }
     store<u64>(bs.offset, 32088598323265570, 0);
     store<u64>(bs.offset, 30962384884727923, 8);
     store<u64>(bs.offset, 9570583007002721, 16);
@@ -256,6 +245,11 @@ class Player {
     store<u32>(bs.offset, 3801122, 24);
     bs.offset += 28;
     JSON.__serialize<Array<i32>>(load<Array<i32>>(ptr, offsetof<this>("lastActive")));
+    store<u64>(bs.offset, 31244203453448236, 0);
+    store<u32>(bs.offset, 2228339, 8);
+    store<u16>(bs.offset, 58, 12);
+    bs.offset += 14;
+    JSON.__serialize<Vec3 | null>(load<Vec3 | null>(ptr, offsetof<this>("pos")));
     store<u64>(bs.offset, 32370073295519788, 0);
     store<u64>(bs.offset, 29555362187509846, 8);
     store<u64>(bs.offset, 28147931469643878, 16);
@@ -552,10 +546,12 @@ class Player {
           if (load<u64>(srcStart) == 30399761348886638) {
             srcStart += 8;
             switch (<u32>keyEnd - <u32>keyStart) {
-              case 6: {
-                const code48 = load<u64>(keyStart) & 281474976710655;
-                if (code48 == 493928513648) {
-                  store<usize>(changetype<usize>(out), 0, offsetof<this>("pos"));
+              case 20: {
+                const codeS8 = load<u64>(keyStart, 0);
+                const codeS16 = load<u64>(keyStart, 8);
+                const codeS20 = load<u32>(keyStart, 16);
+                if (codeS8 == 32370111954878566 && codeS16 == 27303545189433460 && codeS20 == 6619245) {
+                  store<usize>(changetype<usize>(out), 0, offsetof<this>("firstName"));
                   srcStart += 2;
                   keyStart = 0;
                   break;
@@ -566,12 +562,10 @@ class Player {
                 }
               }
 
-              case 20: {
-                const codeS8 = load<u64>(keyStart, 0);
-                const codeS16 = load<u64>(keyStart, 8);
-                const codeS20 = load<u32>(keyStart, 16);
-                if (codeS8 == 32370111954878566 && codeS16 == 27303545189433460 && codeS20 == 6619245) {
-                  store<usize>(changetype<usize>(out), 0, offsetof<this>("firstName"));
+              case 6: {
+                const code48 = load<u64>(keyStart) & 281474976710655;
+                if (code48 == 493928513648) {
+                  store<usize>(changetype<usize>(out), 0, offsetof<this>("pos"));
                   srcStart += 2;
                   keyStart = 0;
                   break;
@@ -598,6 +592,7 @@ class Player {
   }
 }
 const player: Player = {
+  firstName: "Jairus",
   lastName: "Tanaka",
   lastActive: [3, 9, 2025],
   age: 18,

package/assembly/test.ts

@@ -1,4 +1,3 @@
-import { JSON } from ".";
 
 @json
 class Vec3 {
@@ -19,7 +18,6 @@ class Player {
   @omitif((self: Player) => self.age < 18)
   age!: i32;
 
-  @omitnull()
   pos!: Vec3 | null;
   isVerified!: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-as",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "author": "Jairus Tanaka",
   "repository": {
     "type": "git",
@@ -9,11 +9,11 @@
   "main": "transform/lib/index.js",
   "devDependencies": {
     "@assemblyscript/wasi-shim": "^0.1.0",
-    "@types/node": "^22.15.24",
-    "assemblyscript": "^0.28.1",
+    "@types/node": "^22.15.34",
+    "assemblyscript": "^0.28.2",
     "assemblyscript-prettier": "^3.0.1",
-    "prettier": "^3.5.3",
-    "tsx": "^4.19.4",
+    "prettier": "^3.6.2",
+    "tsx": "^4.20.3",
     "typescript": "^5.8.3"
   },
   "bugs": {

package/run-bench.as.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 RUNTIMES=${RUNTIMES:-"minimal stub"}
 ENGINES=${ENGINES:-"liftoff ignition sparkplug turbofan llvm"}
-for file in ./assembly/__benches__/large.bench.ts; do
+for file in ./assembly/__benches__/medium.bench.ts; do
     filename=$(basename -- "$file")
     output_wasi=
     for runtime in $RUNTIMES; do

package/run-tests.sh

@@ -4,24 +4,28 @@ mkdir -p ./build
 
 for file in ./assembly/__tests__/*.spec.ts; do
   filename=$(basename -- "$file")
-  output="./build/${filename%.ts}.wasm"
+  if [ -z "$1" ] || [ "$1" = "$filename" ]; then
+    output="./build/${filename%.ts}.wasm"
 
-  start_time=$(date +%s%3N)
-  npx asc "$file" --transform ./transform -o "$output" --enable simd --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --disableWarning 226 || { echo "Tests failed"; exit 1; }
-  end_time=$(date +%s%3N) 
+    start_time=$(date +%s%3N)
+    npx asc "$file" --transform ./transform -o "$output" --enable simd --config ./node_modules/@assemblyscript/wasi-shim/asconfig.json --disableWarning 226 || { echo "Tests failed"; exit 1; }
+    end_time=$(date +%s%3N)
 
-  build_time=$((end_time - start_time))
+    build_time=$((end_time - start_time))
 
-  if [ "$build_time" -ge 60000 ]; then
-    formatted_time="$(bc <<< "scale=2; $build_time/60000")m"
-  elif [ "$build_time" -ge 1000 ]; then
-    formatted_time="$(bc <<< "scale=2; $build_time/1000")s"
+    if [ "$build_time" -ge 60000 ]; then
+      formatted_time="$(bc <<< "scale=2; $build_time/60000")m"
+    elif [ "$build_time" -ge 1000 ]; then
+      formatted_time="$(bc <<< "scale=2; $build_time/1000")s"
+    else
+      formatted_time="${build_time}ms"
+    fi
+
+    echo " -> $filename (built in $formatted_time)"
+    wasmtime "$output" || { echo "Tests failed"; exit 1; }
   else
-    formatted_time="${build_time}ms"
+    echo " -> $filename (skipped)"
   fi
-
-  echo " -> $filename (built in $formatted_time)"
-  wasmtime "$output" || { echo "Tests failed"; exit 1; }
 done
 
 echo "All tests passed"

package/transform/lib/index.js

@@ -4,14 +4,13 @@ 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 { writeFileSync } from "fs";
+import { Property, PropertyFlags, Schema, 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 {
@@ -21,8 +20,7 @@ export class JSONTransform extends Visitor {
     parser;
     schemas = new Map();
     schema;
-    src;
-    sources = new Map();
+    sources = new SourceSet();
     imports = [];
     simdStatements = [];
     visitedClasses = new Set();
@@ -43,14 +41,9 @@ export class JSONTransform extends Visitor {
             return name === "json" || name === "serializable";
         }))
             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);
-        if (this.visitedClasses.has(source.internalPath + node.name.text))
+        const source = this.sources.get(node.range.source);
+        const fullClassPath = source.getFullPath(node);
+        if (this.visitedClasses.has(fullClassPath))
             return;
         if (!this.schemas.has(source.internalPath))
             this.schemas.set(source.internalPath, []);
@@ -59,9 +52,9 @@ export class JSONTransform extends Visitor {
         const deserializers = [...node.members.filter((v) => v.kind === 58 && v.decorators && v.decorators.some((e) => e.name.text.toLowerCase() === "deserializer"))];
         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) {
@@ -72,36 +65,37 @@ export class JSONTransform extends Visitor {
                     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);
+                            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 " + externalSearch.range.source.internalPath);
+                                throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
                             schema.deps.push(schem);
                             schema.parent = schem;
                         }
@@ -119,7 +113,7 @@ export class JSONTransform extends Visitor {
         }
         const getUnknownTypes = (type, types = []) => {
             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));
             }
@@ -155,39 +149,40 @@ export class JSONTransform extends Visitor {
                     }
                 }
                 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);
                             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);
+                            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 " + externalSearch.range.source.internalPath);
+                                throw new Error("Could not find schema for " + externalSearch.name.text + " in " + externalSource.internalPath);
                             schema.deps.push(schem);
                         }
                     }
@@ -196,7 +191,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";
         let DESERIALIZE = "__DESERIALIZE<__JSON_T>(srcStart: usize, srcEnd: usize, out: __JSON_T): __JSON_T {\n";
@@ -257,7 +252,7 @@ export class JSONTransform extends Visitor {
             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;
             if (type.startsWith("(") && type.includes("=>"))
@@ -324,8 +319,8 @@ export class JSONTransform extends Visitor {
             const aliasName = JSON.stringify(member.alias || member.name);
             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`;
                 }
             }
@@ -938,7 +933,7 @@ export class JSONTransform extends Visitor {
     generateEmptyMethods(node) {
         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);
             console.log(INITIALIZE_EMPTY);
@@ -965,14 +960,22 @@ export class JSONTransform extends Visitor {
     addImports(node) {
         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);
+        }
         fromPath = fromPath.startsWith("~lib") ? fromPath.slice(5) : path.join(this.baseCWD, fromPath);
         const bsImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "bs" || d.name.text == "bs"));
         const jsonImport = this.imports.find((i) => i.declarations?.find((d) => d.foreignName.text == "JSON" || d.name.text == "JSON"));
         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;
@@ -1217,16 +1220,6 @@ function isPrimitive(type) {
 function isBoolean(type) {
     return type == "bool" || type == "boolean";
 }
-function isStruct(type) {
-    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) {
     return stripNull(type) == "string" || stripNull(type) == "String";
 }