ventojs 0.12.1 → 0.12.2

package/esm/src/transformer.js

@@ -1,183 +0,0 @@
-import * as dntShim from "../_dnt.shims.js";
-import { astring, meriyah, walker } from "../deps.js";
-// List of identifiers that are in globalThis
-// but should be accessed as templateState.identifier
-const INCLUDE_GLOBAL = [
-    "name",
-];
-// List of identifiers that should be ignored
-// when transforming the code
-const DEFAULT_EXCLUDES = [
-    "globalThis",
-    "self",
-    "global",
-    "this",
-    "undefined",
-    "null",
-];
-// Tracks the scope of the code
-// and the variables that should be ignored
-class ScopeTracker {
-    scopes = [];
-    // The index of the global/function scope
-    globalScope = 0;
-    includes(val) {
-        for (let i = this.scopes.length - 1; i >= 0; i--) {
-            if (this.scopes[i].stack.includes(val)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    pushScope(global) {
-        if (global) {
-            this.globalScope = this.scopes.length;
-        }
-        const newScope = {
-            globalScope: this.globalScope,
-            stack: [],
-        };
-        this.scopes.push(newScope);
-    }
-    popScope() {
-        this.globalScope = this.scopes[this.scopes.length - 1].globalScope;
-        this.scopes.pop();
-    }
-    pushBinding(val, global) {
-        if (this.scopes.length === 0) {
-            this.scopes.push({ globalScope: this.globalScope, stack: [] });
-        }
-        if (global) {
-            this.scopes[this.globalScope].stack.push(val);
-        }
-        else {
-            this.scopes[this.scopes.length - 1].stack.push(val);
-        }
-    }
-    pushPatternBinding(pattern, global) {
-        switch (pattern.type) {
-            case "Identifier":
-                this.pushBinding(pattern.name, global);
-                break;
-            case "RestElement":
-                this.pushPatternBinding(pattern.argument, global);
-                break;
-            case "ArrayPattern":
-                for (const element of pattern.elements) {
-                    if (element) {
-                        this.pushPatternBinding(element, global);
-                    }
-                }
-                break;
-            case "ObjectPattern":
-                for (const prop of pattern.properties) {
-                    if (prop.type === "RestElement") {
-                        this.pushPatternBinding(prop.argument, global);
-                    }
-                    else {
-                        this.pushPatternBinding(prop.value, global);
-                    }
-                }
-                break;
-            case "AssignmentPattern":
-                this.pushPatternBinding(pattern.left, global);
-                break;
-        }
-    }
-    pushPatternBindings(patterns, global) {
-        for (const pattern of patterns) {
-            this.pushPatternBinding(pattern, global);
-        }
-    }
-}
-export function transformTemplateCode(code, templateState) {
-    if (!code.trim()) {
-        return code;
-    }
-    const parsed = meriyah.parseScript(code, { module: true });
-    const tracker = new ScopeTracker();
-    const exclude = [
-        templateState,
-        ...DEFAULT_EXCLUDES,
-    ];
-    if (parsed.type !== "Program") {
-        throw new Error("Expected a program");
-    }
-    if (parsed.body.length === 0) {
-        throw new Error("Empty program");
-    }
-    // Transforms an identifier to a MemberExpression
-    // if it's not in the exclude list
-    //
-    // Example:
-    // Transforms {{ name }} to {{ id.name }}
-    function transformIdentifier(id) {
-        if ((!INCLUDE_GLOBAL.includes(id.name) &&
-            dntShim.dntGlobalThis[id.name] !== undefined) ||
-            exclude.includes(id.name) ||
-            tracker.includes(id.name) ||
-            id.name.startsWith("__")) {
-            return id;
-        }
-        return {
-            type: "MemberExpression",
-            object: {
-                type: "Identifier",
-                name: templateState,
-            },
-            optional: false,
-            computed: false,
-            property: id,
-        };
-    }
-    walker.walk(parsed, {
-        enter(node) {
-            switch (node.type) {
-                // Track variable declarations
-                case "VariableDeclaration":
-                    // "var" declarations are scoped to the function/global scope.
-                    tracker.pushPatternBindings(node.declarations.map((d) => d.id), node.kind === "var");
-                    break;
-                // Track function declarations, and
-                // function parameters.
-                // Also track the scope.
-                case "FunctionDeclaration":
-                case "FunctionExpression":
-                    if (node.id) {
-                        tracker.pushBinding(node.id.name);
-                    }
-                    tracker.pushScope(true);
-                    tracker.pushPatternBindings(node.params);
-                    break;
-                case "ArrowFunctionExpression":
-                    tracker.pushScope();
-                    tracker.pushPatternBindings(node.params);
-                    break;
-            }
-        },
-        leave(node, parent) {
-            switch (node.type) {
-                // Pop the scope when leaving a function
-                case "FunctionDeclaration":
-                case "FunctionExpression":
-                case "ArrowFunctionExpression":
-                    tracker.popScope();
-                    break;
-                case "Identifier":
-                    // Don't transform identifiers that aren't at the start of a MemberExpression
-                    // ie. don't transform `bar` or `baz` in `foo.bar.baz`
-                    if (parent?.type === "MemberExpression" && parent.property === node) {
-                        return;
-                    }
-                    // Don't transform identifiers that are keys in an object
-                    if (parent?.type === "Property" && parent.key === node) {
-                        return;
-                    }
-                    this.replace(transformIdentifier(node));
-                    break;
-            }
-        },
-    });
-    const generated = astring.generate(parsed);
-    return generated;
-}