@grey-ts/transpiler 0.3.2 → 1.1.0

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2025 Oskari Hirsikangas
+Copyright 2026 Oskari Hirsikangas
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/dist/index.js

@@ -234,6 +234,8 @@ var propertyAccessReplacements = {
   "Math.round": "round",
   "Math.random": "rnd",
   "Math.log": "log",
+  "console.log": "print",
+  "console.clear": "clear_screen",
   "String.prototype": "string",
   "Number.prototype": "number",
   "Boolean.prototype": "number",
@@ -432,8 +434,34 @@ ${name}.${NodeHandler.handle(member)}`;
 NodeHandler.register(ts5.SyntaxKind.Constructor, (node) => {
   if (!node.body)
     return "";
-  const params = node.parameters.map((param) => NodeHandler.handle(param)).join(", ");
-  const body = NodeHandler.handle(node.body);
+  const declaredProperties = [];
+  const params = node.parameters.map((param) => {
+    const res = NodeHandler.handle(param);
+    if (param.modifiers) {
+      const paramName = NodeHandler.handle(param.name);
+      const declaration = `	self.${paramName} = ${paramName}`;
+      declaredProperties.push(declaration);
+    }
+    return res;
+  }).join(", ");
+  let body = NodeHandler.handle(node.body);
+  if (declaredProperties.length) {
+    const propertiesStr = declaredProperties.join(`
+`);
+    const lines = body.split(`
+`);
+    const superIndex = lines.findIndex((line) => line.includes("super.constructor"));
+    if (superIndex !== -1) {
+      body = `${lines.slice(0, superIndex + 1).join(`
+`)}
+${propertiesStr}
+${lines.slice(superIndex + 1).join(`
+`)}`;
+    } else {
+      body = `${propertiesStr}
+${body}`;
+    }
+  }
   return `constructor = function(${params})
 ${body}
 	return self
@@ -460,7 +488,7 @@ end function`;
 // src/visitors/expressions.ts
 import ts7 from "typescript";
 
-// src/callTransformer.ts
+// src/call_transformers/callTransformer.ts
 import path2 from "node:path";
 import ts6 from "typescript";
 class CallTransformer {
@@ -477,60 +505,6 @@ class CallTransformer {
     return handler(functionName, callArgs, node, ctx);
   }
 }
-CallTransformer.register("Array.concat", (name, args) => {
-  const dotI = name.lastIndexOf(".");
-  const arrayName = name.slice(0, dotI);
-  return callUtilFunction("array_concat", arrayName, args.join(","));
-});
-CallTransformer.register("Array.map", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_map", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.filter", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_filter", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.find", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_find", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.some", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_some", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.every", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_every", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.slice", (name, args) => {
-  return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
-});
-CallTransformer.register("Array.push", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_push", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.unshift", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("array_unshift", name.slice(0, name.lastIndexOf(".")), args[0]);
-});
-CallTransformer.register("Array.toString", (name) => {
-  const arrayName = name.slice(0, name.lastIndexOf("."));
-  return `str(${arrayName})`;
-});
-CallTransformer.register("Array.reverse", (name) => {
-  return callUtilFunction("array_reverse", name.slice(0, name.lastIndexOf(".")));
-});
-CallTransformer.register("Object.toString", (name) => {
-  const objectName = name.slice(0, name.lastIndexOf("."));
-  return `str(${objectName})`;
-});
 CallTransformer.register("Number.toString", (name) => {
   const number = name.slice(0, name.lastIndexOf("."));
   return `str(${number})`;
@@ -539,49 +513,12 @@ CallTransformer.register("Function.toString", (name) => {
   const func = name.slice(0, name.lastIndexOf("."));
   return `str(@${func})`;
 });
-CallTransformer.register("String.startsWith", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("str_starts_with", name.slice(0, name.lastIndexOf(".")), ...args);
-});
-CallTransformer.register("String.endsWith", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("str_ends_with", name.slice(0, name.lastIndexOf(".")), ...args);
-});
-CallTransformer.register("String.repeat", (name, args) => {
-  if (!args.length)
-    throw "Invalid argument count";
-  return callUtilFunction("str_repeat", name.slice(0, name.lastIndexOf(".")), ...args);
-});
-CallTransformer.register("String.slice", (name, args) => {
-  return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
-});
-CallTransformer.register("String.toString", (name) => {
-  return name.slice(0, name.lastIndexOf("."));
-});
 CallTransformer.register("Math.min", (name, args) => {
   return callUtilFunction("math_min", `${args.join(",")}`);
 });
 CallTransformer.register("Math.max", (name, args) => {
   return callUtilFunction("math_max", `${args.join(",")}`);
 });
-CallTransformer.register("ObjectConstructor.hasOwn", (name, args) => {
-  if (args.length < 2)
-    throw "Invalid argument count";
-  return `${args[0]}.hasIndex(${args[1]})`;
-});
-CallTransformer.register("ObjectConstructor.assign", (name, args) => {
-  if (args.length < 2)
-    throw "Invalid argument count";
-  return callUtilFunction("assign_objects", args.join(","));
-});
-CallTransformer.register("ObjectConstructor.keys", (name, args) => {
-  return `${args[0]}.indexes`;
-});
-CallTransformer.register("ObjectConstructor.values", (name, args) => {
-  return `${args[0]}.values`;
-});
 CallTransformer.register("GreyHack.include", (name, args, node, ctx) => {
   if (!node.arguments.length)
     return "";
@@ -692,6 +629,8 @@ function handleCallArgs(callNode, ctx) {
   if (restArrays.length) {
     result.push(restArrays.join(" + "));
   }
+  if (hasRestParameter && result.length === params.length - 1)
+    result.push("[]");
   return result;
 }
 NodeHandler.register(ts7.SyntaxKind.CallExpression, (node, ctx) => {
@@ -968,17 +907,30 @@ NodeHandler.register(ts9.SyntaxKind.Parameter, (node) => {
   const name = NodeHandler.handle(node.name);
   if (!node.initializer)
     return name;
-  return `${name} = ${NodeHandler.handle(node.initializer)}`;
+  const initializer = NodeHandler.handle(node.initializer);
+  const initializerType = checker.getTypeAtLocation(node.initializer);
+  if (initializerType.flags === ts9.TypeFlags.Object) {
+    throw `You can't initialize parameter '${name}' with an Array or an Object as that won't work in GreyScript and it would be null`;
+  }
+  return `${name} = ${initializer}`;
 });
 NodeHandler.register(ts9.SyntaxKind.NumericLiteral, (node) => node.text);
 NodeHandler.register(ts9.SyntaxKind.StringLiteral, (node) => `"${transformString(node.text)}"`);
-NodeHandler.register(ts9.SyntaxKind.ThisKeyword, () => "self");
 NodeHandler.register(ts9.SyntaxKind.NullKeyword, () => "null");
 NodeHandler.register(ts9.SyntaxKind.UndefinedKeyword, () => "null");
 NodeHandler.register(ts9.SyntaxKind.FalseKeyword, () => "0");
 NodeHandler.register(ts9.SyntaxKind.TrueKeyword, () => "1");
+NodeHandler.register(ts9.SyntaxKind.ThisKeyword, (node) => {
+  const propDeclarationAncestor = ts9.findAncestor(node.parent, (n) => ts9.isPropertyDeclaration(n));
+  if (propDeclarationAncestor) {
+    if (!propDeclarationAncestor.parent.name)
+      throw `Can't handle this 'this' keyword becuase the class doesn't have a name and it's needed for this case`;
+    return propDeclarationAncestor.parent.name.text;
+  }
+  return "self";
+});
 NodeHandler.register(ts9.SyntaxKind.SuperKeyword, (node) => {
-  if (ts9.isPropertyAccessExpression(node.parent))
+  if (ts9.isPropertyAccessExpression(node.parent) || ts9.isElementAccessExpression(node.parent))
     return "super";
   return "super.constructor";
 });
@@ -1307,7 +1259,7 @@ import ts13 from "typescript";
 function handleVariableDeclaration(node, ctx) {
   const left = NodeHandler.handle(node.name);
   const initializerType = node.initializer ? checker.getTypeAtLocation(node.initializer) : undefined;
-  if (ts13.isPropertyDeclaration(node) && initializerType?.flags === ts13.TypeFlags.Object) {
+  if (ts13.isPropertyDeclaration(node) && initializerType?.flags === ts13.TypeFlags.Object && !node.modifiers?.some((mod) => mod.kind === ts13.SyntaxKind.StaticKeyword)) {
     console.warn(`You shouldn't initialize '${left}' with an Array or an Object because in GreyScript, every instantiation refers to the same '${left}' variable.
 Initialize them in the constructor instead`);
   }
@@ -1343,6 +1295,124 @@ NodeHandler.register(ts13.SyntaxKind.EnumDeclaration, (node) => {
   return `${node.name.text} = { ${members.join(", ")} }`;
 });
 
+// src/call_transformers/array.ts
+CallTransformer.register("Array.concat", (name, args) => {
+  const dotI = name.lastIndexOf(".");
+  const arrayName = name.slice(0, dotI);
+  return callUtilFunction("array_concat", arrayName, args.join(","));
+});
+CallTransformer.register("Array.map", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_map", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.filter", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_filter", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.find", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_find", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.some", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_some", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.every", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_every", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.slice", (name, args) => {
+  return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
+});
+CallTransformer.register("Array.push", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_push", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.unshift", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("array_unshift", name.slice(0, name.lastIndexOf(".")), args[0]);
+});
+CallTransformer.register("Array.toString", (name) => {
+  const arrayName = name.slice(0, name.lastIndexOf("."));
+  return `str(${arrayName})`;
+});
+CallTransformer.register("Array.reverse", (name) => {
+  return callUtilFunction("array_reverse", name.slice(0, name.lastIndexOf(".")));
+});
+
+// src/call_transformers/object.ts
+CallTransformer.register("ObjectConstructor.hasOwn", (name, args) => {
+  if (args.length < 2)
+    throw "Invalid argument count";
+  return `${args[0]}.hasIndex(${args[1]})`;
+});
+CallTransformer.register("ObjectConstructor.assign", (name, args) => {
+  if (args.length < 2)
+    throw "Invalid argument count";
+  return callUtilFunction("assign_objects", args.join(","));
+});
+CallTransformer.register("ObjectConstructor.keys", (name, args) => {
+  return `${args[0]}.indexes`;
+});
+CallTransformer.register("ObjectConstructor.values", (name, args) => {
+  return `${args[0]}.values`;
+});
+CallTransformer.register("ObjectConstructor.sum", (name, args) => {
+  return `${args[0]}.sum`;
+});
+CallTransformer.register("ObjectConstructor.shuffle", (name, args) => {
+  return `${args[0]}.shuffle`;
+});
+CallTransformer.register("ObjectConstructor.replace", (name, args) => {
+  return `${args[0]}.replace(${args.slice(1).join(",")})`;
+});
+CallTransformer.register("ObjectConstructor.remove", (name, args) => {
+  return `${args[0]}.remove(${args[1]})`;
+});
+CallTransformer.register("ObjectConstructor.shift", (name, args) => {
+  return `${args[0]}.pull`;
+});
+CallTransformer.register("ObjectConstructor.size", (name, args) => {
+  return `${args[0]}.len`;
+});
+CallTransformer.register("ObjectConstructor.indexOf", (name, args) => {
+  return `${args[0]}.indexOf(${args[1]})`;
+});
+CallTransformer.register("Object.toString", (name) => {
+  const objectName = name.slice(0, name.lastIndexOf("."));
+  return `str(${objectName})`;
+});
+
+// src/call_transformers/string.ts
+CallTransformer.register("String.startsWith", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("str_starts_with", name.slice(0, name.lastIndexOf(".")), ...args);
+});
+CallTransformer.register("String.endsWith", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("str_ends_with", name.slice(0, name.lastIndexOf(".")), ...args);
+});
+CallTransformer.register("String.repeat", (name, args) => {
+  if (!args.length)
+    throw "Invalid argument count";
+  return callUtilFunction("str_repeat", name.slice(0, name.lastIndexOf(".")), ...args);
+});
+CallTransformer.register("String.slice", (name, args) => {
+  return name.slice(0, name.lastIndexOf(".")) + `[${args[0] ?? ""}:${args[1] ?? ""}]`;
+});
+CallTransformer.register("String.toString", (name) => {
+  return name.slice(0, name.lastIndexOf("."));
+});
+
 // src/transpiler.ts
 var program;
 var checker;
@@ -1357,8 +1427,9 @@ var utilFunctions2 = {
     '\twhile isaobj.hasIndex("__isa")',
     '\t\tisaobj = obj["__isa"]',
     "\t\tif isaobj.hasIndex(key) then",
-    "\t\t\tval = obj[key]",
-    "\t\t\treturn val",
+    "\t\t\tres = obj[key]",
+    '\t\t\tif typeof(@res) == "function" and str(@res)[8:][1:-1].indexOf("self") == 0 then return res(obj)',
+    "\t\t\treturn obj[key]",
     "\t\tend if",
     "\tend while",
     "\treturn null",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/transpiler",
-	"version": "0.3.2",
+	"version": "1.1.0",
 	"description": "Transpiles TypeScript into GreyScript",
 	"author": "Okka",
 	"module": "src/index.ts",
@@ -40,6 +40,6 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"@grey-ts/types": "^1.5.0"
+		"@grey-ts/types": "^2.0.0"
 	}
 }