json-as 1.2.1 → 1.2.2-beta.1

package/transform/src/linkers/alias.ts

@@ -1,58 +0,0 @@
-import { Node, Source, TypeDeclaration, TypeNode } from "assemblyscript/dist/assemblyscript.js";
-import { Visitor } from "../visitor.js";
-import { toString } from "../util.js";
-
-class AliasFinder extends Visitor {
-  visitTypeDeclaration(node: TypeDeclaration, ref?: Node | null): void {
-    TypeAlias.add(node.name.text, node.type);
-  }
-}
-
-export class TypeAlias {
-  public name: string;
-  public type: TypeAlias | string;
-
-  constructor(name: string, type: TypeAlias | string) {
-    this.name = name;
-    this.type = type;
-  }
-
-  getBaseType(type: TypeAlias | string = this.type): string {
-    if (typeof type === "string") return type;
-    return this.getBaseType(type.type);
-  }
-
-  static foundAliases: Map<string, string> = new Map<string, string>();
-  static aliases: Map<string, TypeAlias> = new Map<string, TypeAlias>();
-
-  static add(name: string, type: TypeNode): void {
-    if (!TypeAlias.foundAliases.has(name)) {
-      TypeAlias.foundAliases.set(name, toString(type));
-    } else {
-      const existingType = TypeAlias.foundAliases.get(name);
-      if (existingType !== toString(type)) {
-        throw new Error(`Type alias conflict for ${name}: "${existingType}" vs "${toString(type)}"`);
-      }
-    }
-  }
-
-  static getAliases(source: Source): TypeAlias[] {
-    this.foundAliases.clear();
-    this.aliases.clear();
-
-    const finder = new AliasFinder();
-    finder.visit(source);
-
-    for (const [name, typeStr] of this.foundAliases) {
-      this.aliases.set(name, new TypeAlias(name, typeStr));
-    }
-
-    for (const alias of this.aliases.values()) {
-      if (typeof alias.type === "string" && this.aliases.has(alias.type)) {
-        alias.type = this.aliases.get(alias.type)!;
-      }
-    }
-
-    return [...this.aliases.values()];
-  }
-}

package/transform/src/linkers/custom.ts

@@ -1,32 +0,0 @@
-import { CallExpression, IdentifierExpression, Node, NodeKind, PropertyAccessExpression } from "assemblyscript/dist/assemblyscript.js";
-import { Visitor } from "../visitor.js";
-
-export class CustomTransform extends Visitor {
-  static SN: CustomTransform = new CustomTransform();
-  private modify: boolean = false;
-  visitCallExpression(node: CallExpression) {
-    super.visit(node.args, node);
-    if (node.expression.kind != NodeKind.PropertyAccess || (node.expression as PropertyAccessExpression).property.text != "stringify") return;
-    if ((node.expression as PropertyAccessExpression).expression.kind != NodeKind.Identifier || ((node.expression as PropertyAccessExpression).expression as IdentifierExpression).text != "JSON") return;
-
-    if (this.modify) {
-      (node.expression as PropertyAccessExpression).expression = Node.createPropertyAccessExpression(Node.createIdentifierExpression("JSON", node.expression.range), Node.createIdentifierExpression("internal", node.expression.range), node.expression.range);
-    }
-    this.modify = true;
-
-    // console.log(toString(node));
-    // console.log(SimpleParser.parseStatement("JSON.internal.stringify").expression.expression)
-  }
-  static visit(node: Node | Node[], ref: Node | null = null): void {
-    if (!node) return;
-    CustomTransform.SN.modify = true;
-    CustomTransform.SN.visit(node, ref);
-    CustomTransform.SN.modify = false;
-  }
-  static hasCall(node: Node | Node[]): boolean {
-    if (!node) return false;
-    CustomTransform.SN.modify = false;
-    CustomTransform.SN.visit(node);
-    return CustomTransform.SN.modify;
-  }
-}

package/transform/src/linkers/imports.ts

@@ -1,22 +0,0 @@
-import { ImportStatement, Node, Source } from "assemblyscript/dist/assemblyscript.js";
-import { Visitor } from "../visitor.js";
-
-class ImportGetter extends Visitor {
-  static SN: ImportGetter = new ImportGetter();
-
-  private imports: ImportStatement[] = [];
-
-  visitImportStatement(node: ImportStatement, ref?: Node | null): void {
-    this.imports.push(node);
-  }
-
-  static getImports(source: Source): ImportStatement[] {
-    ImportGetter.SN.imports = [];
-    ImportGetter.SN.visit(source);
-    return ImportGetter.SN.imports;
-  }
-}
-
-export function getImports(source: Source): ImportStatement[] {
-  return ImportGetter.getImports(source);
-}

package/transform/src/types.ts

@@ -1,300 +0,0 @@
-import { ClassDeclaration, Expression, FieldDeclaration, Source, NodeKind, Node, NamespaceDeclaration, DeclarationStatement, TypeName, Parser, ImportStatement, CommonFlags, EnumDeclaration } from "assemblyscript/dist/assemblyscript.js";
-import { TypeAlias } from "./linkers/alias.js";
-import { stripNull } from "./index.js";
-
-export enum PropertyFlags {
-  OmitNull,
-  OmitIf,
-  Raw,
-  Custom,
-}
-
-export class Property {
-  public name: string = "";
-  public alias: string | null = null;
-  public type: string = "";
-  public value: string | null = null;
-  public flags: Map<PropertyFlags, Expression | null> = new Map<PropertyFlags, Expression | null>();
-  public node!: FieldDeclaration;
-  public byteSize: number = 0;
-  public _generic: boolean = false;
-  public _custom: boolean = false;
-  public parent: Schema;
-  set custom(value: boolean) {
-    this._custom = value;
-  }
-  get custom(): boolean {
-    if (this._custom) return true;
-    if (this.parent.node.isGeneric && this.parent.node.typeParameters.some((p) => p.name.text == this.type)) {
-      // console.log("Custom (Generic): " + this.name);
-      // this._generic = true;
-      this._custom = true;
-      return true;
-    }
-
-    for (const dep of this.parent.deps) {
-      if (this.name == dep.name && dep.custom) {
-        // console.log("Custom (Dependency): " + this.name);
-        this._custom = true;
-        return true;
-      }
-    }
-    return false;
-  }
-  set generic(value: boolean) {
-    this._generic = value;
-  }
-  get generic(): boolean {
-    if (this._generic) return true;
-    if (this.parent.node.isGeneric && this.parent.node.typeParameters.some((p) => p.name.text == stripNull(this.type))) {
-      // console.log("Generic: " + this.name);
-      this._generic = true;
-      return true;
-    }
-    return false;
-  }
-}
-
-export class Schema {
-  public static: boolean = true;
-  public name: string = "";
-  public members: Property[] = [];
-  public parent: Schema | null = null;
-  public node!: ClassDeclaration;
-  public needsLink: string | null = null;
-  public byteSize: number = 0;
-  public deps: Schema[] = [];
-  private _custom: boolean = false;
-
-  set custom(value: boolean) {
-    this._custom = value;
-  }
-  get custom(): boolean {
-    if (this._custom) return true;
-    if (this.parent) return this.parent.custom;
-  }
-}
-
-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 exports: Schema[];
-  public imports: ImportStatement[] = [];
-  private nodeMap: Map<Node, NamespaceDeclaration[]> = new Map<Node, NamespaceDeclaration[]>();
-  private classes: Record<string, ClassDeclaration> = {};
-  private enums: Record<string, EnumDeclaration> = {};
-
-  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.EnumDeclaration:
-          const enumDeclaration = node as EnumDeclaration;
-          this.enums[this.qualifiedName(enumDeclaration, path)] = enumDeclaration;
-          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 an enum declaration by its qualified name.
-   * @param qualifiedName Qualified name (eg. "Namespace.MyEnum")
-   * @returns Enum declaration or null if not found.
-   */
-  getEnum(qualifiedName: string): EnumDeclaration | null {
-    return this.enums[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;
-  }
-
-  /**
-   * Get imported enum from other sources in the parser.
-   * @param qualifiedName Qualified name of enum.
-   * @param parser AssemblyScript parser.
-   * @returns Enum declaration or null if not found.
-   */
-  getImportedEnum(qualifiedName: string, parser: Parser): EnumDeclaration | 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 enumDeclaration = source.getEnum(qualifiedName);
-      if (enumDeclaration && enumDeclaration.flags & CommonFlags.Export) {
-        return enumDeclaration;
-      }
-    }
-    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/util.ts

@@ -1,128 +0,0 @@
-// Taken from https://github.com/as-pect/visitor-as/blob/master/src/simpleParser.ts
-import { Parser, Tokenizer, Source, SourceKind, Expression, Statement, NamespaceDeclaration, ClassDeclaration, DeclarationStatement, Range, Node, NodeKind } from "assemblyscript/dist/assemblyscript.js";
-import { ASTBuilder } from "./builder.js";
-import * as path from "path";
-
-export class SimpleParser {
-  private static get parser(): Parser {
-    return new Parser();
-  }
-
-  private static getTokenizer(s: string, file: string = "index.ts"): Tokenizer {
-    return new Tokenizer(new Source(SourceKind.User, file, s));
-  }
-
-  static parseExpression(s: string): Expression {
-    const res = this.parser.parseExpression(this.getTokenizer(s));
-    if (res == null) {
-      throw new Error("Failed to parse the expression: '" + s + "'");
-    }
-    return res;
-  }
-
-  static parseStatement(s: string, topLevel = false): Statement {
-    const res = this.parser.parseStatement(this.getTokenizer(s), topLevel);
-    if (res == null) {
-      throw new Error("Failed to parse the statement: '" + s + "'");
-    }
-    return res;
-  }
-
-  static parseTopLevelStatement(s: string, namespace?: NamespaceDeclaration | null): Statement {
-    const res = this.parser.parseTopLevelStatement(this.getTokenizer(s), namespace);
-    if (res == null) {
-      throw new Error("Failed to parse the top level statement: '" + s + "'");
-    }
-    return res;
-  }
-
-  static parseClassMember(s: string, _class: ClassDeclaration): DeclarationStatement {
-    let res = this.parser.parseClassMember(this.getTokenizer(s, _class.range.source.normalizedPath), _class);
-    if (res == null) {
-      throw new Error("Failed to parse the class member: '" + s + "'");
-    }
-    return <DeclarationStatement>res;
-  }
-}
-
-let isStdlibRegex = /\~lib\/(?:array|arraybuffer|atomics|builtins|crypto|console|compat|dataview|date|diagnostics|error|function|iterator|map|math|number|object|process|reference|regexp|set|staticarray|string|symbol|table|typedarray|vector|rt\/?|bindings\/|shared\/typeinfo)|util\/|uri|polyfills|memory/;
-
-export function isStdlib(s: Source | { range: Range }): boolean {
-  let source = s instanceof Source ? s : s.range.source;
-  return isStdlibRegex.test(source.internalPath);
-}
-
-export function toString(node: Node): string {
-  return ASTBuilder.build(node);
-}
-
-export function replaceRef(node: Node, replacement: Node | Node[], ref: Node | Node[] | null): void {
-  if (!node || !ref) return;
-  const nodeExpr = stripExpr(node);
-
-  if (Array.isArray(ref)) {
-    for (let i = 0; i < ref.length; i++) {
-      if (stripExpr(ref[i]) === nodeExpr) {
-        if (Array.isArray(replacement)) ref.splice(i, 1, ...replacement);
-        else ref.splice(i, 1, replacement);
-        return; // Exit early after replacement
-      }
-    }
-  } else if (typeof ref === "object") {
-    for (const key of Object.keys(ref)) {
-      const current = ref[key] as Node | Node[];
-      if (Array.isArray(current)) {
-        for (let i = 0; i < current.length; i++) {
-          if (stripExpr(current[i]) === nodeExpr) {
-            if (Array.isArray(replacement)) current.splice(i, 1, ...replacement);
-            else current.splice(i, 1, replacement);
-            return;
-          }
-        }
-      } else if (stripExpr(current) === nodeExpr) {
-        ref[key] = replacement;
-        return;
-      }
-    }
-  }
-}
-
-export function cloneNode(input: Node | Node[] | null, seen = new WeakMap(), path = ""): Node | Node[] | null {
-  if (input === null || typeof input !== "object") return input;
-
-  if (Array.isArray(input)) {
-    return input.map((item, index) => cloneNode(item, seen, `${path}[${index}]`)) as Node | Node[] | null;
-  }
-
-  if (seen.has(input)) return seen.get(input);
-
-  const prototype = Object.getPrototypeOf(input);
-  const clone = Array.isArray(input) ? [] : Object.create(prototype);
-  seen.set(input, clone);
-
-  for (const key of Reflect.ownKeys(input)) {
-    const value = input[key];
-    const newPath = path ? `${path}.${String(key)}` : String(key);
-
-    if (newPath.endsWith(".source")) {
-      clone[key] = value;
-    } else if (value && typeof value === "object") {
-      clone[key] = cloneNode(value, seen, newPath);
-    } else {
-      clone[key] = value;
-    }
-  }
-
-  return clone as Node | Node[] | null;
-}
-
-export function stripExpr(node: Node): Node {
-  if (!node) return node;
-  if (node.kind == NodeKind.Expression) return node["expression"];
-  return node;
-}
-
-export function removeExtension(filePath: string): string {
-  const parsed = path.parse(filePath);
-  return path.join(parsed.dir, parsed.name);
-}