@grey-ts/transpiler 0.1.0 → 0.3.0

package/README.md

@@ -18,4 +18,4 @@ bun/npx greyts transpile pathToMyFile.ts
 ```
 
 
-<!-- To easily start writing your code for GreyHack, use [this template](https://github.com/OkkaOk/grey-ts-template) instead of using this manually. -->
+To easily start writing your code for GreyHack, use [this template](https://github.com/OkkaOk/grey-ts-template) instead of using this manually.

package/dist/index.js

@@ -174,8 +174,11 @@ var apiNameMap = {
   "String.isMatch": "is_match",
   "String.toInt": "to_int",
   "String.length": "len",
+  "String.toLowerCase": "lower",
+  "String.toUpperCase": "upper",
   "Object.size": "len",
-  "Array.length": "len"
+  "Array.length": "len",
+  "Array.shift": "pull"
 };
 var propertyAccessReplacements = {
   "Math.PI": "pi",
@@ -195,6 +198,7 @@ var propertyAccessReplacements = {
   "Math.log": "log",
   "String.prototype": "string",
   "Number.prototype": "number",
+  "Boolean.prototype": "number",
   "Object.prototype": "map",
   "Array.prototype": "list",
   "Function.prototype": "funcRef"
@@ -511,6 +515,56 @@ var utilFunctions2 = {
     "\treturn out",
     "end function"
   ].join(`
+`),
+  array_push: [
+    "array_push = function(target, items)",
+    "\tfor item in items",
+    "\t\ttarget.push(item)",
+    "\tend for",
+    "\treturn target.len",
+    "end function"
+  ].join(`
+`),
+  array_unshift: [
+    "array_unshift = function(target, items)",
+    "\tif not items.len then return target.len",
+    "\tfor i in range(items.len-1)",
+    "\t\ttarget.insert(0, items[i])",
+    "\tend for",
+    "\treturn target.len",
+    "end function"
+  ].join(`
+`),
+  array_reverse: `array_reverse = function(arr)
+	arr.reverse
+	return arr
+end function`,
+  str_starts_with: [
+    "str_starts_with = function(str, search, pos = 0)",
+    "\tif pos < 0 then pos = 0",
+    "\treturn str.indexOf(search) == pos",
+    "end function"
+  ].join(`
+`),
+  str_ends_with: [
+    "str_ends_with = function(str, search, pos = null)",
+    "\tif pos == null then pos = str.len",
+    "\tif pos < 0 then pos = 0",
+    "\treturn str.indexOf(search) + search.len == pos",
+    "end function"
+  ].join(`
+`),
+  str_repeat: [
+    "str_repeat = function(str, count = 0)",
+    '\tif count <= 0 then return ""',
+    "\tif count == 1 then return str",
+    "\tout = str",
+    "\tfor i in range(count-2)",
+    "\t\tout = out + str",
+    "\tend for",
+    "\treturn out",
+    "end function"
+  ].join(`
 `),
   math_min: [
     "math_min = function(numbers)",
@@ -707,7 +761,7 @@ NodeHandler.register(ts5.SyntaxKind.SetAccessor, (node) => {
     return "";
   const body = NodeHandler.handle(node.body);
   const params = node.parameters.map((param) => NodeHandler.handle(param));
-  return `${NodeHandler.handle(node.name)} = function(${params.join(", ")})
+  return `set_${NodeHandler.handle(node.name)} = function(${params.join(", ")})
 ${body}
 end function`;
 });
@@ -762,6 +816,59 @@ CallTransformer.register("Array.every", (name, args) => {
     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})`;
+});
+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(",")}`);
 });
@@ -781,6 +888,9 @@ CallTransformer.register("ObjectConstructor.assign", (name, args) => {
 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 "";
@@ -794,6 +904,21 @@ CallTransformer.register("GreyHack.include", (name, args, node, ctx) => {
   }
   return "";
 });
+CallTransformer.register("Boolean", (name, args) => {
+  if (!args.length)
+    return "0";
+  return `(not (not ${args[0]}))`;
+});
+CallTransformer.register("Number", (name, args) => {
+  if (!args.length)
+    return "0";
+  return `str(${args[0]}).val`;
+});
+CallTransformer.register("String", (name, args) => {
+  if (!args.length)
+    return "";
+  return `str(${args[0]})`;
+});
 
 // src/visitors/expressions.ts
 function hasRestParam(params) {
@@ -915,11 +1040,17 @@ NodeHandler.register(ts7.SyntaxKind.BinaryExpression, (node) => {
   if (ts7.isPropertyAccessExpression(node.left)) {
     const leftType = checker.getTypeAtLocation(node.left.expression);
     const symbol = leftType.getProperty(node.left.name.text);
-    if (symbol?.declarations && ts7.isSetAccessor(symbol.declarations[0])) {
-      if (operatorToken != "=") {
-        throw "Set accessor can only work with = operator for now.";
+    if (symbol?.declarations?.some((decl) => ts7.isSetAccessor(decl))) {
+      const objName = NodeHandler.handle(node.left.expression);
+      const key = node.left.name.text;
+      if (operatorToken !== "=" && symbol.declarations.some((decl) => ts7.isGetAccessor(decl)))
+        throw `Can't handle '${operatorToken}' because '${objName}' doesn't have a getter '${key}'`;
+      if (operatorToken === "+=" || operatorToken === "-=") {
+        right = `${objName}.${key} ${operatorToken[0]} ${right}`;
+      } else if (operatorToken !== "=") {
+        throw `The transpiler can't handle ${operatorToken} operator for setters yet`;
       }
-      return `${NodeHandler.handle(node.left.expression)}.${node.left.name.text}(${right})`;
+      return `${objName}.set_${key}(${right})`;
     }
   }
   let left = NodeHandler.handle(node.left);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grey-ts/transpiler",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"author": "Okka",
 	"module": "src/index.ts",
 	"bin": {
@@ -39,6 +39,6 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"@grey-ts/types": "https://github.com/OkkaOk/grey-ts-types"
+		"@grey-ts/types": "^1.5.0"
 	}
 }