jpsx 0.1.16

package/dist/transformer/transformer.js

@@ -0,0 +1,318 @@
+export function transform(program) {
+    const body = program.body.map(transformStatement);
+    return { type: "Program", body };
+}
+function transformStatement(statement) {
+    if (statement.type === "ExpressionStatement") {
+        return { ...statement, expression: transformExpression(statement.expression) };
+    }
+    if (statement.type === "FunctionDeclaration") {
+        let name = statement.name;
+        let params = statement.params;
+        if (name === "__init__") {
+            name = "constructor";
+            params = params.filter(p => p !== "self"); // Remove self
+        }
+        else {
+            // Remove self from normal methods too if present
+            params = params.filter(p => p !== "self");
+        }
+        return {
+            ...statement,
+            name,
+            params,
+            body: statement.body.map(transformStatement),
+        };
+    }
+    if (statement.type === "ForStatement") {
+        if (statement.collection) {
+            return {
+                ...statement,
+                collection: transformExpression(statement.collection),
+                body: statement.body.map(transformStatement)
+            };
+        }
+        return {
+            ...statement,
+            start: transformExpression(statement.start),
+            end: transformExpression(statement.end),
+            body: statement.body.map(transformStatement),
+        };
+    }
+    if (statement.type === "IfStatement") {
+        return {
+            ...statement,
+            test: transformExpression(statement.test),
+            consequent: statement.consequent.map(transformStatement),
+            alternate: statement.alternate ? statement.alternate.map(transformStatement) : null,
+        };
+    }
+    if (statement.type === "WhileStatement") {
+        return {
+            ...statement,
+            test: transformExpression(statement.test),
+            body: statement.body.map(transformStatement),
+        };
+    }
+    if (statement.type === "ClassDeclaration") {
+        return {
+            ...statement,
+            body: statement.body.map(transformStatement)
+        };
+    }
+    if (statement.type === "TryStatement") {
+        return {
+            ...statement,
+            block: statement.block.map(transformStatement),
+            handler: statement.handler.map(transformStatement)
+        };
+    }
+    if (statement.type === "ReturnStatement") {
+        return {
+            ...statement,
+            argument: statement.argument ? transformExpression(statement.argument) : null
+        };
+    }
+    if (statement.type === "ExportDeclaration") {
+        return {
+            ...statement,
+            declaration: transformStatement(statement.declaration)
+        };
+    }
+    // ImportDeclaration passes through IDENTITY
+    return statement;
+}
+function isSuperCall(expr) {
+    return expr.type === "CallExpression" && expr.callee.type === "Identifier" && expr.callee.name === "super";
+}
+function transformExpression(expression) {
+    if (!expression)
+        return expression;
+    if (expression.type === "CallExpression") {
+        const { callee, args } = expression;
+        // Handle obj.method(...) transformations
+        if (callee.type === "MemberExpression") {
+            const obj = callee.object;
+            const prop = callee.property;
+            // Handle super().__init__(...) -> super(...)
+            if (isSuperCall(obj) && prop.type === "Identifier" && prop.name === "__init__") {
+                return {
+                    type: "CallExpression",
+                    callee: { type: "Identifier", name: "super" },
+                    args: args.map(transformExpression)
+                };
+            }
+            // Handle dictionary methods mappings
+            if (!callee.computed && prop.type === "Identifier") {
+                if (prop.name === "get") {
+                    const keyArg = args[0];
+                    const defaultArg = args[1] || { type: "Identifier", name: "undefined" };
+                    return {
+                        type: "ConditionalExpression",
+                        test: {
+                            type: "BinaryExpression",
+                            operator: "in",
+                            left: transformExpression(keyArg),
+                            right: transformExpression(obj)
+                        },
+                        consequent: {
+                            type: "MemberExpression",
+                            object: transformExpression(obj),
+                            property: transformExpression(keyArg),
+                            computed: true
+                        },
+                        alternate: transformExpression(defaultArg)
+                    };
+                }
+                if (prop.name === "items") {
+                    return {
+                        type: "CallExpression",
+                        callee: {
+                            type: "MemberExpression",
+                            object: { type: "Identifier", name: "Object" },
+                            property: { type: "Identifier", name: "entries" },
+                            computed: false
+                        },
+                        args: [transformExpression(obj)]
+                    };
+                }
+                if (prop.name === "keys") {
+                    return {
+                        type: "CallExpression",
+                        callee: {
+                            type: "MemberExpression",
+                            object: { type: "Identifier", name: "Object" },
+                            property: { type: "Identifier", name: "keys" },
+                            computed: false
+                        },
+                        args: [transformExpression(obj)]
+                    };
+                }
+                if (prop.name === "values") {
+                    return {
+                        type: "CallExpression",
+                        callee: {
+                            type: "MemberExpression",
+                            object: { type: "Identifier", name: "Object" },
+                            property: { type: "Identifier", name: "values" },
+                            computed: false
+                        },
+                        args: [transformExpression(obj)]
+                    };
+                }
+            }
+        }
+        // Handle sorted(iterable, key=..., reverse=...) -> sorted(iterable, key, reverse)
+        if (callee.type === "Identifier" && callee.name === "sorted") {
+            const iterable = args[0] ? transformExpression(args[0]) : { type: "Identifier", name: "undefined" };
+            let key = { type: "Identifier", name: "undefined" };
+            let reverse = { type: "BooleanLiteral", value: false };
+            // Process arguments to find named args
+            for (let i = 1; i < args.length; i++) {
+                const arg = args[i];
+                if (arg.type === "BinaryExpression" && arg.operator === "=" && arg.left.type === "Identifier") {
+                    const name = arg.left.name;
+                    if (name === "key") {
+                        key = transformExpression(arg.right);
+                    }
+                    else if (name === "reverse") {
+                        reverse = transformExpression(arg.right);
+                    }
+                }
+                else {
+                    // Assume positional mappings if not named: 2nd is key, 3rd is reverse
+                    if (i === 1)
+                        key = transformExpression(arg);
+                    if (i === 2)
+                        reverse = transformExpression(arg);
+                }
+            }
+            return {
+                type: "CallExpression",
+                callee: { type: "Identifier", name: "sorted" },
+                args: [iterable, key, reverse]
+            };
+        }
+        if (callee.type === "Identifier") {
+            // Heuristic for new Class(...)
+            if (/^[A-Z]/.test(callee.name)) {
+                const exceptions = ["String", "Number", "Boolean", "Object", "Array", "Error"];
+                if (!exceptions.includes(callee.name)) {
+                    return {
+                        type: "NewExpression",
+                        callee: { type: "Identifier", name: callee.name },
+                        args: args.map(transformExpression)
+                    };
+                }
+            }
+        }
+        const transformedCallee = transformExpression(callee);
+        return { ...expression, callee: transformedCallee, args: args.map(transformExpression) };
+    }
+    if (expression.type === "MemberExpression") {
+        if (isSuperCall(expression.object)) {
+            return {
+                ...expression,
+                object: { type: "Identifier", name: "super" },
+                property: transformExpression(expression.property)
+            };
+        }
+        const prop = expression.property;
+        if (!expression.computed && prop.type === "Identifier") {
+            if (prop.name === "upper") {
+                return {
+                    ...expression,
+                    object: transformExpression(expression.object),
+                    property: { type: "Identifier", name: "toUpperCase" },
+                    computed: false
+                };
+            }
+            if (prop.name === "lower") {
+                return {
+                    ...expression,
+                    object: transformExpression(expression.object),
+                    property: { type: "Identifier", name: "toLowerCase" },
+                    computed: false
+                };
+            }
+            if (prop.name === "strip") {
+                return {
+                    ...expression,
+                    object: transformExpression(expression.object),
+                    property: { type: "Identifier", name: "trim" },
+                    computed: false
+                };
+            }
+            if (prop.name === "append") {
+                return {
+                    ...expression,
+                    object: transformExpression(expression.object),
+                    property: { type: "Identifier", name: "push" },
+                    computed: false
+                };
+            }
+        }
+        return {
+            ...expression,
+            object: transformExpression(expression.object),
+            property: expression.computed ? transformExpression(expression.property) : expression.property
+        };
+    }
+    if (expression.type === "Identifier") {
+        if (expression.name === "self") {
+            return { type: "Identifier", name: "this" };
+        }
+        if (expression.name === "None") {
+            return { type: "Identifier", name: "null" };
+        }
+    }
+    if (expression.type === "LambdaExpression") {
+        return {
+            ...expression,
+            body: transformExpression(expression.body)
+        };
+    }
+    if (expression.type === "BinaryExpression") {
+        if (expression.operator === "in") {
+            return {
+                type: "CallExpression",
+                callee: { type: "Identifier", name: "__in__" },
+                args: [transformExpression(expression.left), transformExpression(expression.right)]
+            };
+        }
+        return {
+            ...expression,
+            left: transformExpression(expression.left),
+            right: transformExpression(expression.right),
+        };
+    }
+    if (expression.type === "ListComprehension") {
+        return {
+            ...expression,
+            expression: transformExpression(expression.expression),
+            start: expression.start ? transformExpression(expression.start) : undefined,
+            end: expression.end ? transformExpression(expression.end) : undefined,
+            collection: expression.collection ? transformExpression(expression.collection) : undefined,
+            test: expression.test ? transformExpression(expression.test) : undefined,
+        };
+    }
+    if (expression.type === "UnaryExpression") {
+        return {
+            ...expression,
+            argument: transformExpression(expression.argument)
+        };
+    }
+    if (expression.type === "ArrayLiteral") {
+        return {
+            type: "ArrayLiteral",
+            elements: expression.elements.map(transformExpression),
+        };
+    }
+    if (expression.type === "ObjectLiteral") {
+        return {
+            type: "ObjectLiteral",
+            properties: expression.properties.map((p) => ({ ...p, value: transformExpression(p.value) })),
+        };
+    }
+    return expression;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "jpsx",
+  "version": "0.1.16",
+  "description": "Just Python Script (JPS) - A Python-like language that compiles to JavaScript",
+  "keywords": [
+    "compiler",
+    "python",
+    "javascript",
+    "jps"
+  ],
+  "author": "Loaii abdalslam",
+  "license": "ISC",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "jps": "./dist/cli/index.js"
+  },
+  "main": "./dist/api/index.js",
+  "types": "./dist/api/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/api/index.d.ts",
+      "import": "./dist/api/index.js",
+      "require": "./dist/api/index.cjs"
+    },
+    "./cli": "./dist/cli/index.js",
+    "./runtime": "./dist/runtime/index.js",
+    "./package.json": "./package.json"
+  },
+  "private": false,
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/cli/index.js",
+    "test": "jest"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "moo": "^0.5.2",
+    "nearley": "^2.20.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.12",
+    "@types/moo": "^0.5.10",
+    "@types/nearley": "^2.11.5",
+    "@types/node": "^22.19.7",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.3.3"
+  }
+}