babel-plugin-vasille 0.99.0

package/lib-node/transformer.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trProgram = trProgram;
+const t = __importStar(require("@babel/types"));
+const internal_js_1 = require("./internal.js");
+const mesh_js_1 = require("./mesh.js");
+const imports = new Map([["vasille-dx", "VasilleDX"], ["vasille-web", "VasilleWeb"]]);
+const ignoreMembers = new Set([
+    "value",
+    "ref",
+    "bind",
+    "calculate",
+    "watch",
+    "arrayModel",
+    "mapModel",
+    "reactiveObject",
+    "setModel",
+]);
+function extractText(node) {
+    return t.isIdentifier(node) ? node.name : node.value;
+}
+function trProgram(path, devMode) {
+    let id;
+    const internal = {
+        get id() {
+            this.internalUsed = true;
+            return id;
+        },
+        set id(expr) {
+            id = expr;
+        },
+        stack: new internal_js_1.StackedStates(),
+        mapping: new Map(),
+        global: "",
+        prefix: "Vasille_",
+        importStatement: null,
+        internalUsed: false,
+        devMode: devMode,
+    };
+    for (const statementPath of path.get("body")) {
+        const statement = statementPath.node;
+        if (t.isImportDeclaration(statement)) {
+            const name = imports.get(statement.source.value);
+            if (name) {
+                internal.prefix = `${name}_`;
+                for (const specifier of statement.specifiers) {
+                    if (t.isImportNamespaceSpecifier(specifier)) {
+                        internal.global = specifier.local.name;
+                        id = t.memberExpression(t.identifier(internal.global), t.identifier("$"));
+                    }
+                    else if (t.isImportSpecifier(specifier)) {
+                        const imported = extractText(specifier.imported);
+                        const local = specifier.local.name;
+                        internal.mapping.set(local, imported);
+                        if (!id) {
+                            id = t.identifier(name);
+                        }
+                        internal.importStatement = statementPath;
+                    }
+                }
+                statement.specifiers = statement.specifiers.filter(spec => {
+                    if (!t.isImportSpecifier(spec)) {
+                        return true;
+                    }
+                    else {
+                        return !ignoreMembers.has(extractText(spec.imported));
+                    }
+                });
+            }
+        }
+        else {
+            if (!id) {
+                return;
+            }
+            (0, mesh_js_1.meshStatement)(statementPath, internal);
+        }
+    }
+    if (internal.internalUsed && !internal.global && internal.importStatement) {
+        const statementPath = internal.importStatement;
+        const statement = statementPath.node;
+        statementPath.replaceWith(t.importDeclaration([
+            ...statement.specifiers.filter(item => {
+                if (t.isImportSpecifier(item) && t.isIdentifier(item.local)) {
+                    return statementPath.scope.bindings[item.local.name].referenced;
+                }
+                return true;
+            }),
+            t.importSpecifier(internal.id, t.identifier("$")),
+        ], statement.source));
+    }
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "babel-plugin-vasille",
+  "version": "0.99.0",
+  "description": "",
+  "main": "lib/index.js",
+  "type": "module",
+  "exports": {
+    "import": "./lib/index.js",
+    "browser": "./lib/index.js",
+    "node": "./lib-node/index.js",
+    "require": "./lib-node/index.js"
+  },
+  "scripts": {
+    "prepack": "cp -f ../README.md ./README.md",
+    "prettier": "prettier src test/**/*.ts* --write",
+    "build": "tsc --build tsconfig-build.json",
+    "build-node": "tsc --build tsconfig-build-node.json",
+    "test": "jest",
+    "test-coverage": "jest --coverage"
+  },
+  "keywords": [
+    "front-end",
+    "framework",
+    "dx"
+  ],
+  "author": "lixcode",
+  "license": "MIT",
+  "dependencies": {
+    "vasille-dx": "^3.0.1"
+  },
+  "devDependencies": {
+    "@babel/parser": "^7.26.1",
+    "@babel/plugin-syntax-jsx": "^7.25.9",
+    "@babel/plugin-transform-typescript": "^7.25.9",
+    "@babel/types": "^7.26.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/jest": "^29.5.14",
+    "@types/jsdom": "^21.1.7",
+    "@types/node": "^22.8.1",
+    "jest": "^29.7.0",
+    "jsdom": "^25.0.1",
+    "path": "^0.12.7",
+    "prettier": "^3.3.3",
+    "ts-jest": "^29.2.5",
+    "typescript": "^5.6.3"
+  }
+}