babel-plugin-vasille 0.99.0

package/lib/transformer.js

@@ -0,0 +1,88 @@
+import * as t from "@babel/types";
+import { StackedStates } from "./internal.js";
+import { meshStatement } from "./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;
+}
+export function trProgram(path, devMode) {
+    let id;
+    const internal = {
+        get id() {
+            this.internalUsed = true;
+            return id;
+        },
+        set id(expr) {
+            id = expr;
+        },
+        stack: new 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;
+            }
+            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/lib-node/call.js

@@ -0,0 +1,78 @@
+"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.requiresContext = exports.composeOnly = void 0;
+exports.calls = calls;
+const t = __importStar(require("@babel/types"));
+const internal_js_1 = require("./internal.js");
+exports.composeOnly = [
+    "forward",
+    "watch",
+    "ref",
+    "bind",
+    "value",
+    "arrayModel",
+    "mapModel",
+    "setModel",
+    "reactiveObject",
+];
+exports.requiresContext = ["awaited", "forward"];
+const requiresContextSet = new Set(exports.requiresContext);
+function calls(node, names, internal) {
+    const set = new Set(names);
+    const callee = t.isCallExpression(node) ? node.callee : null;
+    if (callee) {
+        if (t.isIdentifier(callee)) {
+            const mapped = internal.mapping.get(callee.name);
+            if (mapped && set.has(mapped) && internal.stack.get(callee.name) === undefined) {
+                if (requiresContextSet.has(callee.name) && t.isCallExpression(node)) {
+                    node.arguments.unshift(internal_js_1.ctx);
+                }
+                return mapped;
+            }
+            return false;
+        }
+        // The global object is overrided
+        if (internal.stack.get(internal.global) !== undefined) {
+            return false;
+        }
+        const propName = t.isMemberExpression(callee)
+            ? t.isIdentifier(callee.property)
+                ? callee.property.name
+                : t.isStringLiteral(callee.property)
+                    ? callee.property.value
+                    : null
+            : null;
+        if (t.isMemberExpression(callee) && t.isIdentifier(callee.object) && propName) {
+            if (callee.object.name === internal.global && set.has(propName)) {
+                if (requiresContextSet.has(callee.object.name) && t.isCallExpression(node)) {
+                    node.arguments.unshift(internal_js_1.ctx);
+                }
+                return callee.object.name;
+            }
+        }
+    }
+    return false;
+}