@grey-ts/transpiler 0.3.2 → 1.0.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",
@@ -460,7 +462,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 +479,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 +487,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 +603,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) => {
@@ -1343,6 +1256,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 +1388,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.0.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"
 	}
 }