@wyw-in-js/transform 0.1.0

package/types/utils/valueToLiteral.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueToLiteral = void 0;
+const getSource_1 = require("./getSource");
+const isSerializable_1 = require("./isSerializable");
+function valueToLiteral(value, ex) {
+    if (value === undefined) {
+        return {
+            type: 'Identifier',
+            name: 'undefined',
+        };
+    }
+    if ((0, isSerializable_1.isSerializable)(value)) {
+        if (value === null) {
+            return {
+                type: 'NullLiteral',
+            };
+        }
+        if (typeof value === 'string') {
+            return {
+                type: 'StringLiteral',
+                value,
+            };
+        }
+        if (typeof value === 'number') {
+            return {
+                type: 'NumericLiteral',
+                value,
+            };
+        }
+        if (typeof value === 'boolean') {
+            return {
+                type: 'BooleanLiteral',
+                value,
+            };
+        }
+        if (Array.isArray(value)) {
+            return {
+                type: 'ArrayExpression',
+                elements: value.map((v) => valueToLiteral(v, ex)),
+            };
+        }
+        return {
+            type: 'ObjectExpression',
+            properties: Object.entries(value).map(([key, v]) => ({
+                type: 'ObjectProperty',
+                key: key.match(/^[a-zA-Z]\w*$/)
+                    ? {
+                        type: 'Identifier',
+                        name: key,
+                    }
+                    : {
+                        type: 'StringLiteral',
+                        value: key,
+                    },
+                value: valueToLiteral(v, ex),
+                computed: false,
+                shorthand: false,
+            })),
+        };
+    }
+    throw ex.buildCodeFrameError(`The expression evaluated to '${value}', which is probably a mistake. If you want it to be inserted into CSS, explicitly cast or transform the value to a string, e.g. - 'String(${(0, getSource_1.getSource)(ex)})'.`);
+}
+exports.valueToLiteral = valueToLiteral;

package/types/utils/visitors/JSXElementsRemover.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from '@babel/traverse';
+import type { CallExpression, JSX } from '@babel/types';
+export declare function JSXElementsRemover(path: NodePath<JSX | CallExpression>): void;

package/types/utils/visitors/JSXElementsRemover.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSXElementsRemover = void 0;
+const core_1 = require("@babel/core");
+const getScope_1 = require("../getScope");
+const scopeHelpers_1 = require("../scopeHelpers");
+function getFunctionName(path) {
+    if (path.isClassMethod() && core_1.types.isIdentifier(path.node.key)) {
+        return path.node.key.name;
+    }
+    return null;
+}
+function JSXElementsRemover(path) {
+    // JSX can be safely replaced with null because it is unnecessary for styles
+    const nullLiteral = core_1.types.nullLiteral();
+    // We can do even more
+    // If that JSX is a result of a function, we can replace the function body.
+    const functionScope = (0, getScope_1.getScope)(path).getFunctionParent();
+    const scopePath = functionScope?.path;
+    if (scopePath?.isFunction()) {
+        const emptyBody = core_1.types.blockStatement([core_1.types.returnStatement(nullLiteral)]);
+        // Is it not just a function, but a method `render`?
+        if (getFunctionName(scopePath) === 'render') {
+            const decl = scopePath.findParent((p) => p.isClassDeclaration());
+            // Replace the whole component
+            if (decl?.isClassDeclaration()) {
+                (0, scopeHelpers_1.mutate)(decl, (p) => {
+                    p.replaceWith(core_1.types.functionDeclaration(decl.node.id, [], emptyBody));
+                });
+                return;
+            }
+        }
+        const body = scopePath.get('body');
+        if (Array.isArray(body)) {
+            throw new Error("A body of a function is expected to be a single element but an array was returned. It's possible if JS syntax has been changed since that code was written.");
+        }
+        const node = {
+            ...scopePath.node,
+            body: emptyBody,
+            params: [],
+        };
+        (0, scopeHelpers_1.mutate)(scopePath, (p) => {
+            p.replaceWith(node);
+        });
+    }
+    else {
+        (0, scopeHelpers_1.mutate)(path, (p) => {
+            p.replaceWith(nullLiteral);
+        });
+    }
+}
+exports.JSXElementsRemover = JSXElementsRemover;

package/types/vm/createVmContext.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import * as vm from 'vm';
+import type { FeatureFlags, StrictOptions } from '@wyw-in-js/shared';
+export declare function createVmContext(filename: string, features: FeatureFlags<'happyDOM'>, additionalContext: Partial<vm.Context>, overrideContext?: StrictOptions['overrideContext']): {
+    context: vm.Context;
+    teardown: (() => void) | (() => void);
+};

package/types/vm/createVmContext.js

@@ -0,0 +1,92 @@
+"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.createVmContext = void 0;
+const vm = __importStar(require("vm"));
+const shared_1 = require("@wyw-in-js/shared");
+const process = __importStar(require("./process"));
+const NOOP = () => { };
+function createWindow() {
+    const { Window, GlobalWindow } = require('happy-dom');
+    const HappyWindow = GlobalWindow || Window;
+    const win = new HappyWindow();
+    // TODO: browser doesn't expose Buffer, but a lot of dependencies use it
+    win.Buffer = Buffer;
+    win.Uint8Array = Uint8Array;
+    return win;
+}
+function createBaseContext(win, additionalContext) {
+    const baseContext = win ?? {};
+    baseContext.document = win?.document;
+    baseContext.window = win;
+    baseContext.self = win;
+    baseContext.top = win;
+    baseContext.parent = win;
+    baseContext.global = win;
+    baseContext.process = process;
+    baseContext.clearImmediate = NOOP;
+    baseContext.clearInterval = NOOP;
+    baseContext.clearTimeout = NOOP;
+    baseContext.setImmediate = NOOP;
+    baseContext.requestAnimationFrame = NOOP;
+    baseContext.setInterval = NOOP;
+    baseContext.setTimeout = NOOP;
+    // eslint-disable-next-line guard-for-in,no-restricted-syntax
+    for (const key in additionalContext) {
+        baseContext[key] = additionalContext[key];
+    }
+    return baseContext;
+}
+function createHappyDOMWindow() {
+    const win = createWindow();
+    return {
+        teardown: () => {
+            win.happyDOM.cancelAsync();
+        },
+        window: win,
+    };
+}
+function createNothing() {
+    return {
+        teardown: () => { },
+        window: undefined,
+    };
+}
+function createVmContext(filename, features, additionalContext, overrideContext = (i) => i) {
+    const isHappyDOMEnabled = (0, shared_1.isFeatureEnabled)(features, 'happyDOM', filename);
+    const { teardown, window } = isHappyDOMEnabled
+        ? createHappyDOMWindow()
+        : createNothing();
+    const baseContext = createBaseContext(window, overrideContext({
+        __filename: filename,
+        ...additionalContext,
+    }, filename));
+    const context = vm.createContext(baseContext);
+    return {
+        context,
+        teardown,
+    };
+}
+exports.createVmContext = createVmContext;

package/types/vm/process.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * It contains API for mocked process variable available in node environment used to evaluate scripts with node's `vm` in ./module.ts
+ */
+export declare const nextTick: (fn: (...args: unknown[]) => void) => NodeJS.Timeout;
+export declare const platform = "browser";
+export declare const arch = "browser";
+export declare const execPath = "browser";
+export declare const title = "browser";
+export declare const pid = 1;
+export declare const browser = true;
+export declare const argv: never[];
+export declare const binding: () => never;
+export declare const cwd: () => string;
+export declare const exit: () => void;
+export declare const kill: () => void;
+export declare const chdir: () => void;
+export declare const umask: () => void;
+export declare const dlopen: () => void;
+export declare const uptime: () => void;
+export declare const memoryUsage: () => void;
+export declare const uvCounters: () => void;
+export declare const features: {};
+export declare const env: NodeJS.ProcessEnv;

package/types/vm/process.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.env = exports.features = exports.uvCounters = exports.memoryUsage = exports.uptime = exports.dlopen = exports.umask = exports.chdir = exports.kill = exports.exit = exports.cwd = exports.binding = exports.argv = exports.browser = exports.pid = exports.title = exports.execPath = exports.arch = exports.platform = exports.nextTick = void 0;
+/**
+ * It contains API for mocked process variable available in node environment used to evaluate scripts with node's `vm` in ./module.ts
+ */
+const nextTick = (fn) => setTimeout(fn, 0);
+exports.nextTick = nextTick;
+exports.platform = 'browser';
+exports.arch = 'browser';
+exports.execPath = 'browser';
+exports.title = 'browser';
+exports.pid = 1;
+exports.browser = true;
+exports.argv = [];
+const binding = function binding() {
+    throw new Error('No such module. (Possibly not yet loaded)');
+};
+exports.binding = binding;
+const cwd = () => '/';
+exports.cwd = cwd;
+const noop = () => { };
+exports.exit = noop;
+exports.kill = noop;
+exports.chdir = noop;
+exports.umask = noop;
+exports.dlopen = noop;
+exports.uptime = noop;
+exports.memoryUsage = noop;
+exports.uvCounters = noop;
+exports.features = {};
+exports.env = process.env;