@ssets/babel 1.0.0

package/dist/helper/annotate-as-pure.d.ts

@@ -0,0 +1,4 @@
+import { type Node } from "@babel/types";
+export default function annotateAsPure(pathOrNode: Node | {
+    node: Node;
+}): void;

package/dist/helper/annotate-as-pure.js

@@ -0,0 +1,13 @@
+import { addComment } from "@babel/types";
+const PURE_ANNOTATION = "#__PURE__";
+const isPureAnnotated = ({ leadingComments }) => !!leadingComments &&
+    leadingComments.some((comment) => /[@#]__PURE__/.test(comment.value));
+export default function annotateAsPure(pathOrNode) {
+    const node = 
+    // @ts-expect-error Node will not have `node` property
+    (pathOrNode.node || pathOrNode);
+    if (isPureAnnotated(node)) {
+        return;
+    }
+    addComment(node, "leading", PURE_ANNOTATION);
+}

package/dist/helper/validator-option.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Given a string `str` and an array of candidates `arr`,
+ * return the first of elements in candidates that has minimal
+ * Levenshtein distance with `str`.
+ * @export
+ * @param {string} str
+ * @param {string[]} arr
+ * @returns {string}
+ */
+export declare function findSuggestion(str: string, arr: readonly string[]): string;
+export declare class OptionValidator {
+    descriptor: string;
+    constructor(descriptor: string);
+    /**
+     * Validate if the given `options` follow the name of keys defined in the `TopLevelOptionShape`
+     *
+     * @param {Object} options
+     * @param {Object} TopLevelOptionShape
+     *   An object with all the valid key names that `options` should be allowed to have
+     *   The property values of `TopLevelOptionShape` can be arbitrary
+     * @memberof OptionValidator
+     */
+    validateTopLevelOptions(options: object, TopLevelOptionShape: object): void;
+    validateBooleanOption<T extends boolean>(name: string, value?: boolean, defaultValue?: T): boolean | T;
+    validateStringOption<T extends string>(name: string, value?: string, defaultValue?: T): string | T;
+    /**
+     * A helper interface copied from the `invariant` npm package.
+     * It throws given `message` when `condition` is not met
+     *
+     * @param {boolean} condition
+     * @param {string} message
+     * @memberof OptionValidator
+     */
+    invariant(condition: boolean, message: string): void;
+    formatMessage(message: string): string;
+}

package/dist/helper/validator-option.js

@@ -0,0 +1,100 @@
+const { min } = Math;
+// a minimal leven distance implementation
+// balanced maintainability with code size
+// It is not blazingly fast but should be okay for Babel user case
+// where it will be run for at most tens of time on strings
+// that have less than 20 ASCII characters
+// https://rosettacode.org/wiki/Levenshtein_distance#ES5
+function levenshtein(a, b) {
+    let t = [], u = [], i, j;
+    const m = a.length, n = b.length;
+    if (!m) {
+        return n;
+    }
+    if (!n) {
+        return m;
+    }
+    for (j = 0; j <= n; j++) {
+        t[j] = j;
+    }
+    for (i = 1; i <= m; i++) {
+        for (u = [i], j = 1; j <= n; j++) {
+            u[j] =
+                a[i - 1] === b[j - 1] ? t[j - 1] : min(t[j - 1], t[j], u[j - 1]) + 1;
+        }
+        t = u;
+    }
+    return u[n];
+}
+/**
+ * Given a string `str` and an array of candidates `arr`,
+ * return the first of elements in candidates that has minimal
+ * Levenshtein distance with `str`.
+ * @export
+ * @param {string} str
+ * @param {string[]} arr
+ * @returns {string}
+ */
+export function findSuggestion(str, arr) {
+    const distances = arr.map((el) => levenshtein(el, str));
+    return arr[distances.indexOf(min(...distances))];
+}
+export class OptionValidator {
+    constructor(descriptor) {
+        this.descriptor = descriptor;
+    }
+    /**
+     * Validate if the given `options` follow the name of keys defined in the `TopLevelOptionShape`
+     *
+     * @param {Object} options
+     * @param {Object} TopLevelOptionShape
+     *   An object with all the valid key names that `options` should be allowed to have
+     *   The property values of `TopLevelOptionShape` can be arbitrary
+     * @memberof OptionValidator
+     */
+    validateTopLevelOptions(options, TopLevelOptionShape) {
+        const validOptionNames = Object.keys(TopLevelOptionShape);
+        for (const option of Object.keys(options)) {
+            if (!validOptionNames.includes(option)) {
+                throw new Error(this.formatMessage(`'${option}' is not a valid top-level option.
+- Did you mean '${findSuggestion(option, validOptionNames)}'?`));
+            }
+        }
+    }
+    // note: we do not consider rewrite them to high order functions
+    // until we have to support `validateNumberOption`.
+    validateBooleanOption(name, value, defaultValue) {
+        if (value === undefined) {
+            return defaultValue;
+        }
+        else {
+            this.invariant(typeof value === "boolean", `'${name}' option must be a boolean.`);
+        }
+        return value;
+    }
+    validateStringOption(name, value, defaultValue) {
+        if (value === undefined) {
+            return defaultValue;
+        }
+        else {
+            this.invariant(typeof value === "string", `'${name}' option must be a string.`);
+        }
+        return value;
+    }
+    /**
+     * A helper interface copied from the `invariant` npm package.
+     * It throws given `message` when `condition` is not met
+     *
+     * @param {boolean} condition
+     * @param {string} message
+     * @memberof OptionValidator
+     */
+    invariant(condition, message) {
+        if (!condition) {
+            throw new Error(this.formatMessage(message));
+        }
+    }
+    formatMessage(message) {
+        return `${this.descriptor}: ${message}`;
+    }
+}

package/dist/plugin/display-name.d.ts

@@ -0,0 +1,9 @@
+import babel from "@babel/core";
+interface AllowedCallees {
+    [moduleName: string]: string[];
+}
+export interface PluginOptions {
+    allowedCallees?: AllowedCallees;
+}
+declare const _default: (api: object, options: PluginOptions | null | undefined, dirname: string) => babel.PluginObj<babel.PluginPass>;
+export default _default;

package/dist/plugin/display-name.js

@@ -0,0 +1,339 @@
+import { declare } from "@babel/helper-plugin-utils";
+// remember to set `cacheDirectory` to `false` when modifying this plugin
+const DEFAULT_ALLOWED_CALLEES = {
+    react: ["createContext", "forwardRef", "memo"],
+};
+const calleeModuleMapping = new Map(); // Mapping of callee name to module name
+const seenDisplayNames = new Set();
+/**
+ * Applies allowed callees mapping to the internal calleeModuleMapping.
+ */
+function applyAllowedCallees(mapping) {
+    Object.entries(mapping).forEach(([moduleName, methodNames]) => {
+        methodNames.forEach((methodName) => {
+            const moduleNames = calleeModuleMapping.get(methodName) ?? [];
+            moduleNames.push(moduleName);
+            calleeModuleMapping.set(methodName, moduleNames);
+        });
+    });
+}
+export default declare((api, options) => {
+    api.assertVersion(7);
+    calleeModuleMapping.clear();
+    applyAllowedCallees(DEFAULT_ALLOWED_CALLEES);
+    if (options.allowedCallees) {
+        applyAllowedCallees(options.allowedCallees);
+    }
+    const t = api.types;
+    return {
+        name: "@probablyup/babel-plugin-react-displayname",
+        visitor: {
+            Program() {
+                // We allow duplicate names across files,
+                // so we clear when we're transforming on a new file
+                seenDisplayNames.clear();
+            },
+            "FunctionExpression|ArrowFunctionExpression|ObjectMethod": (path) => {
+                // if the parent is a call expression, make sure it's an allowed one
+                if (path.parentPath && path.parentPath.isCallExpression()
+                    ? isAllowedCallExpression(t, path.parentPath)
+                    : true) {
+                    if (doesReturnJSX(t, path.node.body)) {
+                        addDisplayNamesToFunctionComponent(t, path);
+                    }
+                }
+            },
+            CallExpression(path) {
+                if (isAllowedCallExpression(t, path)) {
+                    addDisplayNamesToFunctionComponent(t, path);
+                }
+            },
+        },
+    };
+});
+/**
+ * Checks if this function returns JSX nodes.
+ * It does not do type-checking, which means calling
+ * other functions that return JSX will still return `false`.
+ */
+function doesReturnJSX(t, node) {
+    if (!node) {
+        return false;
+    }
+    const body = t.toBlock(node).body;
+    if (!body) {
+        return false;
+    }
+    return body.some((statement) => {
+        let currentNode;
+        if (t.isReturnStatement(statement)) {
+            currentNode = statement.argument;
+        }
+        else if (t.isExpressionStatement(statement) &&
+            !t.isCallExpression(statement.expression)) {
+            currentNode = statement.expression;
+        }
+        else {
+            return false;
+        }
+        if (t.isCallExpression(currentNode) &&
+            // detect *.createElement and count it as returning JSX
+            // this could be improved a lot but will work for the 99% case
+            t.isMemberExpression(currentNode.callee) &&
+            t.isIdentifier(currentNode.callee.property) &&
+            currentNode.callee.property.name === "createElement") {
+            return true;
+        }
+        if (t.isConditionalExpression(currentNode)) {
+            return (isJSX(t, currentNode.consequent) || isJSX(t, currentNode.alternate));
+        }
+        if (t.isLogicalExpression(currentNode)) {
+            return isJSX(t, currentNode.left) || isJSX(t, currentNode.right);
+        }
+        if (t.isArrayExpression(currentNode)) {
+            return currentNode.elements.some((ele) => isJSX(t, ele));
+        }
+        return isJSX(t, currentNode);
+    });
+}
+/**
+ * Checks if this node is JSXElement or JSXFragment,
+ * which are the root nodes of react components.
+ */
+function isJSX(t, node) {
+    return t.isJSXElement(node) || t.isJSXFragment(node);
+}
+/**
+ * Checks if this path is an allowed CallExpression.
+ */
+function isAllowedCallExpression(t, path) {
+    const calleePath = path.get("callee");
+    const callee = path.node
+        .callee;
+    const calleeName = callee.name || callee.property?.name;
+    const moduleNames = calleeName && calleeModuleMapping.get(calleeName);
+    if (!moduleNames) {
+        return false;
+    }
+    // If the callee is an identifier expression, then check if it matches
+    // a named import, e.g. `import {createContext} from 'react'`.
+    if (calleePath.isIdentifier()) {
+        return moduleNames.some((moduleName) => calleePath.referencesImport(moduleName, calleeName));
+    }
+    // Otherwise, check if the member expression's object matches
+    // a default import (e.g. `import React from 'react'`)
+    // or namespace import (e.g. `import * as React from 'react')
+    if (calleePath.isMemberExpression()) {
+        const object = calleePath.get("object");
+        return moduleNames.some((moduleName) => object.referencesImport(moduleName, "default") ||
+            object.referencesImport(moduleName, "*"));
+    }
+    return false;
+}
+/**
+ * Adds displayName to the function component if it is:
+ *  - assigned to a variable or object path
+ *  - not within other JSX elements
+ *  - not called by a react hook or _createClass helper
+ */
+function addDisplayNamesToFunctionComponent(t, path) {
+    const componentIdentifiers = [];
+    if (path.node.key) {
+        componentIdentifiers.push({ id: path.node.key });
+    }
+    let assignmentPath;
+    let hasCallee = false;
+    let hasObjectProperty = false;
+    const scopePath = path.scope.parent && path.scope.parent.path;
+    path.find((parentPath) => {
+        // we've hit the scope, stop going further up
+        if (parentPath === scopePath) {
+            return true;
+        }
+        // Ignore functions within jsx
+        if (isJSX(t, parentPath.node)) {
+            return true;
+        }
+        if (parentPath.isCallExpression()) {
+            // Ignore immediately invoked function expressions (IIFEs)
+            const callee = parentPath.node.callee;
+            if (t.isArrowFunctionExpression(callee) ||
+                t.isFunctionExpression(callee)) {
+                return true;
+            }
+            // Ignore instances where displayNames are disallowed
+            // _createClass(() => <Element />)
+            // useMemo(() => <Element />)
+            const calleeName = t.isIdentifier(callee) ? callee.name : undefined;
+            if (calleeName &&
+                (calleeName.startsWith("_") || calleeName.startsWith("use"))) {
+                return true;
+            }
+            hasCallee = true;
+        }
+        // componentIdentifier = <Element />
+        if (parentPath.isAssignmentExpression()) {
+            assignmentPath = parentPath.parentPath;
+            componentIdentifiers.unshift({
+                id: parentPath.node.left,
+            });
+            return true;
+        }
+        // const componentIdentifier = <Element />
+        if (parentPath.isVariableDeclarator()) {
+            // Ternary expression
+            if (t.isConditionalExpression(parentPath.node.init)) {
+                const { consequent, alternate } = parentPath.node.init;
+                const isConsequentFunction = t.isArrowFunctionExpression(consequent) ||
+                    t.isFunctionExpression(consequent);
+                const isAlternateFunction = t.isArrowFunctionExpression(alternate) ||
+                    t.isFunctionExpression(alternate);
+                // Only add display name if variable is a function
+                if (!isConsequentFunction || !isAlternateFunction) {
+                    return false;
+                }
+            }
+            assignmentPath = parentPath.parentPath;
+            componentIdentifiers.unshift({
+                id: parentPath.node.id,
+            });
+            return true;
+        }
+        // if this is not a continuous object key: value pair, stop processing it
+        if (hasObjectProperty &&
+            !(parentPath.isObjectProperty() || parentPath.isObjectExpression())) {
+            return true;
+        }
+        // { componentIdentifier: <Element /> }
+        if (parentPath.isObjectProperty()) {
+            hasObjectProperty = true;
+            const node = parentPath.node;
+            componentIdentifiers.unshift({
+                id: node.key,
+                computed: node.computed,
+            });
+        }
+        return false;
+    });
+    if (!assignmentPath || componentIdentifiers.length === 0) {
+        return;
+    }
+    const name = generateDisplayName(t, componentIdentifiers);
+    const pattern = `${name}.displayName`;
+    // disallow duplicate names if they were assigned in different scopes
+    if (seenDisplayNames.has(name) &&
+        !hasBeenAssignedPrev(t, assignmentPath, pattern, name)) {
+        return;
+    }
+    // skip unnecessary addition of name if it is reassigned later on
+    if (hasBeenAssignedNext(t, assignmentPath, pattern)) {
+        return;
+    }
+    // at this point we're ready to start pushing code
+    if (hasCallee) {
+        // if we're getting called by some wrapper function,
+        // give this function a name
+        setInternalFunctionName(t, path, name);
+    }
+    const displayNameStatement = createDisplayNameStatement(t, componentIdentifiers, name);
+    assignmentPath.insertAfter(displayNameStatement);
+    seenDisplayNames.add(name);
+}
+/**
+ * Generate a displayName string based on the ids collected.
+ */
+function generateDisplayName(t, componentIdentifiers) {
+    let displayName = "";
+    componentIdentifiers.forEach((componentIdentifier) => {
+        const node = componentIdentifier.id;
+        if (!node) {
+            return;
+        }
+        const name = generateNodeDisplayName(t, node);
+        displayName += componentIdentifier.computed ? `[${name}]` : `.${name}`;
+    });
+    return displayName.slice(1);
+}
+/**
+ * Generate a displayName string based on the node.
+ */
+function generateNodeDisplayName(t, node) {
+    if (t.isIdentifier(node)) {
+        return node.name;
+    }
+    if (t.isMemberExpression(node)) {
+        const objectDisplayName = generateNodeDisplayName(t, node.object);
+        const propertyDisplayName = generateNodeDisplayName(t, node.property);
+        const res = node.computed
+            ? `${objectDisplayName}[${propertyDisplayName}]`
+            : `${objectDisplayName}.${propertyDisplayName}`;
+        return res;
+    }
+    return "";
+}
+/**
+ * Checks if this path has been previously assigned to a particular value.
+ */
+function hasBeenAssignedPrev(t, assignmentPath, pattern, value) {
+    return assignmentPath.getAllPrevSiblings().some((sibling) => {
+        const expression = sibling.get("expression");
+        if (!t.isAssignmentExpression(expression.node, { operator: "=" })) {
+            return false;
+        }
+        if (!t.isStringLiteral(expression.node.right, { value })) {
+            return false;
+        }
+        return expression.get("left").matchesPattern(pattern);
+    });
+}
+/**
+ * Checks if this path will be assigned later in the scope.
+ */
+function hasBeenAssignedNext(t, assignmentPath, pattern) {
+    return assignmentPath.getAllNextSiblings().some((sibling) => {
+        const expression = sibling.get("expression");
+        if (!t.isAssignmentExpression(expression.node, { operator: "=" })) {
+            return false;
+        }
+        return expression.get("left").matchesPattern(pattern);
+    });
+}
+/**
+ * Generate a displayName ExpressionStatement node based on the ids.
+ */
+function createDisplayNameStatement(t, componentIdentifiers, displayName) {
+    const node = createMemberExpression(t, componentIdentifiers);
+    const expression = t.assignmentExpression("=", t.memberExpression(node, t.identifier("displayName")), t.stringLiteral(displayName));
+    const ifStatement = t.ifStatement(t.binaryExpression("!==", t.memberExpression(t.memberExpression(t.identifier("process"), t.identifier("env")), t.identifier("NODE_ENV")), t.stringLiteral("production")), t.expressionStatement(expression));
+    return ifStatement;
+}
+/**
+ * Helper that creates a MemberExpression node from the ids.
+ */
+function createMemberExpression(t, componentIdentifiers) {
+    let node = componentIdentifiers[0].id;
+    if (componentIdentifiers.length > 1) {
+        for (let i = 1; i < componentIdentifiers.length; i += 1) {
+            const { id, computed } = componentIdentifiers[i];
+            node = t.memberExpression(node, id, computed);
+        }
+    }
+    return node;
+}
+/**
+ * Changes the arrow function to a function expression and gives it a name.
+ * `name` will be changed to ensure that it is unique within the scope. e.g. `helper` -> `_helper`
+ */
+function setInternalFunctionName(t, path, name) {
+    if (!name ||
+        ("id" in path.node && path.node.id != null) ||
+        ("key" in path.node && path.node.key != null)) {
+        return;
+    }
+    const id = path.scope.generateUidIdentifier(name);
+    if (path.isArrowFunctionExpression()) {
+        path.arrowFunctionToExpression();
+    }
+    // @ts-expect-error Not really an error
+    path.node.id = id;
+}

package/dist/plugin/resolve-imports.d.ts

@@ -0,0 +1,8 @@
+import babel, { PluginObj } from "@babel/core";
+type Options = {
+    outExtension?: string | null;
+};
+export default function plugin({ types }: {
+    types: typeof babel.types;
+}, { outExtension }?: Options): PluginObj;
+export {};

package/dist/plugin/resolve-imports.js

@@ -0,0 +1,62 @@
+import nodePath from "node:path";
+import resolve from "resolve/sync.js";
+function toPosixPath(importPath) {
+    return nodePath
+        .normalize(importPath)
+        .split(nodePath.sep)
+        .join(nodePath.posix.sep);
+}
+function pathToNodeImportSpecifier(importPath) {
+    const normalized = toPosixPath(importPath);
+    return normalized.startsWith("/") || normalized.startsWith(".")
+        ? normalized
+        : `./${normalized}`;
+}
+export default function plugin({ types }, { outExtension } = {}) {
+    const cache = new Map();
+    const extensions = [".mjs", ".js", ".mts", ".ts", ".jsx", ".tsx"];
+    const extensionsSet = new Set(extensions);
+    function doResolve(importSource, state) {
+        const importedPath = importSource.node.value;
+        if (extensionsSet.has(nodePath.extname(importedPath)) ||
+            importedPath.endsWith(".css") ||
+            !importedPath.startsWith(".")) {
+            return;
+        }
+        const importerDir = nodePath.dirname(state.filename);
+        const absoluteImportPath = nodePath.resolve(importerDir, importedPath);
+        let resolvedPath = cache.get(absoluteImportPath);
+        if (!resolvedPath) {
+            try {
+                resolvedPath = resolve(absoluteImportPath, { extensions });
+                if (outExtension &&
+                    extensionsSet.has(nodePath.extname(resolvedPath))) {
+                    const dir = nodePath.dirname(resolvedPath);
+                    const ext = nodePath.extname(resolvedPath);
+                    const base = nodePath.basename(resolvedPath, ext);
+                    resolvedPath = nodePath.resolve(dir, base + outExtension);
+                }
+                cache.set(absoluteImportPath, resolvedPath);
+            }
+            catch (e) {
+                throw new Error(`Could not resolve "${importedPath}" from "${state.filename}"`);
+            }
+        }
+        const relativeResolvedPath = nodePath.relative(importerDir, resolvedPath);
+        importSource.replaceWith(types.stringLiteral(pathToNodeImportSpecifier(relativeResolvedPath)));
+    }
+    return {
+        visitor: {
+            ImportDeclaration(path, state) {
+                doResolve(path.get("source"), state);
+            },
+            ExportNamedDeclaration(path, state) {
+                if (path.get("source").isStringLiteral())
+                    doResolve(path.get("source"), state);
+            },
+            ExportAllDeclaration(path, state) {
+                doResolve(path.get("source"), state);
+            },
+        },
+    };
+}

package/dist/plugin/syntax-typescript.d.ts

@@ -0,0 +1,7 @@
+export interface Options {
+    disallowAmbiguousJSXLike?: boolean;
+    dts?: boolean;
+    isTSX?: boolean;
+}
+declare const _default: (api: object, options: Options | null | undefined, dirname: string) => import("@babel/core").PluginObj<import("@babel/core").PluginPass>;
+export default _default;

package/dist/plugin/syntax-typescript.js

@@ -0,0 +1,15 @@
+// @ts-nocheck
+import { declare } from "@babel/helper-plugin-utils";
+export default declare((api, opts) => {
+    api.assertVersion("^7.0.0-0 || ^8.0.0");
+    const { disallowAmbiguousJSXLike, dts } = opts;
+    return {
+        name: "syntax-typescript",
+        manipulateOptions(opts, parserOpts) {
+            parserOpts.plugins.push([
+                "typescript",
+                { disallowAmbiguousJSXLike, dts },
+            ]);
+        },
+    };
+});

package/dist/plugin/transform-react-display-name.d.ts

@@ -0,0 +1,9 @@
+import { types as t } from "@babel/core";
+declare const _default: (api: object, options: Record<string, any> | null | undefined, dirname: string) => {
+    name: string;
+    visitor: {
+        ExportDefaultDeclaration(this: import("@babel/core").PluginPass, { node }: import("@babel/traverse").NodePath<t.ExportDefaultDeclaration>, state: import("@babel/core").PluginPass): void;
+        CallExpression(this: import("@babel/core").PluginPass, path: import("@babel/traverse").NodePath<t.CallExpression>): void;
+    };
+};
+export default _default;

package/dist/plugin/transform-react-display-name.js

@@ -0,0 +1,97 @@
+import { declare } from "@babel/helper-plugin-utils";
+import path from "node:path";
+import { types as t } from "@babel/core";
+export default declare((api) => {
+    api.assertVersion(7);
+    function addDisplayName(id, call) {
+        const props = call.arguments[0].properties;
+        let safe = true;
+        for (let i = 0; i < props.length; i++) {
+            const prop = props[i];
+            if (t.isSpreadElement(prop)) {
+                continue;
+            }
+            const key = t.toComputedKey(prop);
+            if (t.isStringLiteral(key, { value: "displayName" })) {
+                safe = false;
+                break;
+            }
+        }
+        if (safe) {
+            props.unshift(t.objectProperty(t.identifier("displayName"), t.stringLiteral(id)));
+        }
+    }
+    const isCreateClassCallExpression = t.buildMatchMemberExpression("React.createClass");
+    const isCreateClassAddon = (callee) => t.isIdentifier(callee, { name: "createReactClass" });
+    function isCreateClass(node) {
+        if (!node || !t.isCallExpression(node))
+            return false;
+        // not createReactClass nor React.createClass call member object
+        if (!isCreateClassCallExpression(node.callee) &&
+            !isCreateClassAddon(node.callee)) {
+            return false;
+        }
+        // no call arguments
+        const args = node.arguments;
+        if (args.length !== 1)
+            return false;
+        // first node arg is not an object
+        const first = args[0];
+        if (!t.isObjectExpression(first))
+            return false;
+        return true;
+    }
+    return {
+        name: "transform-react-display-name",
+        visitor: {
+            ExportDefaultDeclaration({ node }, state) {
+                if (isCreateClass(node.declaration)) {
+                    const filename = state.filename || "unknown";
+                    let displayName = path.basename(filename, path.extname(filename));
+                    // ./{module name}/index.js
+                    if (displayName === "index") {
+                        displayName = path.basename(path.dirname(filename));
+                    }
+                    addDisplayName(displayName, node.declaration);
+                }
+            },
+            CallExpression(path) {
+                const { node } = path;
+                if (!isCreateClass(node))
+                    return;
+                let id;
+                // crawl up the ancestry looking for possible candidates for displayName inference
+                path.find(function (path) {
+                    if (path.isAssignmentExpression()) {
+                        id = path.node.left;
+                    }
+                    else if (path.isObjectProperty()) {
+                        id = path.node.key;
+                    }
+                    else if (path.isVariableDeclarator()) {
+                        id = path.node.id;
+                    }
+                    else if (path.isStatement()) {
+                        // we've hit a statement, we should stop crawling up
+                        return true;
+                    }
+                    // we've got an id! no need to continue
+                    if (id)
+                        return true;
+                    return false;
+                });
+                // ensure that we have an identifier we can inherit from
+                if (!id)
+                    return;
+                // foo.bar -> bar
+                if (t.isMemberExpression(id)) {
+                    id = id.property;
+                }
+                // identifiers are the only thing we can reliably get a name from
+                if (t.isIdentifier(id)) {
+                    addDisplayName(id.name, node);
+                }
+            },
+        },
+    };
+});

package/dist/plugin/transform-react-pure-annotations.d.ts

@@ -0,0 +1,8 @@
+import { types as t, type NodePath } from "@babel/core";
+declare const _default: (api: object, options: Record<string, any> | null | undefined, dirname: string) => {
+    name: string;
+    visitor: {
+        CallExpression(this: import("@babel/core").PluginPass, path: NodePath<t.CallExpression>): void;
+    };
+};
+export default _default;

package/dist/plugin/transform-react-pure-annotations.js

@@ -0,0 +1,69 @@
+import { declare } from "@babel/helper-plugin-utils";
+import annotateAsPure from "../helper/annotate-as-pure";
+import { types as t } from "@babel/core";
+// Mapping of React top-level methods that are pure.
+// This plugin adds a /*#__PURE__#/ annotation to calls to these methods,
+// so that terser and other minifiers can safely remove them during dead
+// code elimination.
+// See https://reactjs.org/docs/react-api.html
+const PURE_CALLS = [
+    [
+        "react",
+        new Set([
+            "cloneElement",
+            "createContext",
+            "createElement",
+            "createFactory",
+            "createRef",
+            "forwardRef",
+            "isValidElement",
+            "memo",
+            "lazy",
+        ]),
+    ],
+    ["react-dom", new Set(["createPortal"])],
+];
+export default declare((api) => {
+    api.assertVersion(7);
+    return {
+        name: "transform-react-pure-annotations",
+        visitor: {
+            CallExpression(path) {
+                if (isReactCall(path)) {
+                    annotateAsPure(path);
+                }
+            },
+        },
+    };
+});
+function isReactCall(path) {
+    // If the callee is not a member expression, then check if it matches
+    // a named import, e.g. `import {forwardRef} from 'react'`.
+    const calleePath = path.get("callee");
+    if (!calleePath.isMemberExpression()) {
+        for (const [module, methods] of PURE_CALLS) {
+            for (const method of methods) {
+                if (calleePath.referencesImport(module, method)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // Otherwise, check if the member expression's object matches
+    // a default import (`import React from 'react'`) or namespace
+    // import (`import * as React from 'react'), and check if the
+    // property matches one of the pure methods.
+    const object = calleePath.get("object");
+    const callee = calleePath.node;
+    if (!callee.computed && t.isIdentifier(callee.property)) {
+        const propertyName = callee.property.name;
+        for (const [module, methods] of PURE_CALLS) {
+            if (object.referencesImport(module, "default") ||
+                object.referencesImport(module, "*")) {
+                return methods.has(propertyName);
+            }
+        }
+    }
+    return false;
+}

package/dist/plugin/transform-remove-imports.d.ts

@@ -0,0 +1 @@
+export { default } from "babel-plugin-transform-remove-imports";

package/dist/plugin/transform-remove-imports.js

@@ -0,0 +1 @@
+export { default } from "babel-plugin-transform-remove-imports";

package/dist/plugin/transform-runtime.d.ts

@@ -0,0 +1 @@
+export { default } from "@babel/plugin-transform-runtime";

package/dist/plugin/transform-runtime.js

@@ -0,0 +1 @@
+export { default } from "@babel/plugin-transform-runtime";

package/dist/preset/env.d.ts

@@ -0,0 +1,2 @@
+export { default } from "@babel/preset-env";
+export * from "@babel/preset-env";

package/dist/preset/env.js

@@ -0,0 +1,2 @@
+export { default } from "@babel/preset-env";
+export * from "@babel/preset-env";

package/dist/preset/react/index.d.ts

@@ -0,0 +1,14 @@
+export interface Options {
+    development?: boolean;
+    developmentSourceSelf?: boolean;
+    importSource?: string;
+    pragma?: string;
+    pragmaFrag?: string;
+    pure?: string;
+    runtime?: "automatic" | "classic";
+    throwIfNamespace?: boolean;
+    useBuiltIns?: boolean;
+    useSpread?: boolean;
+}
+declare const _default: (api: object, options: Options | null | undefined, dirname: string) => import("@babel/core").PluginObj<import("@babel/core").PluginPass>;
+export default _default;

package/dist/preset/react/index.js

@@ -0,0 +1,34 @@
+import { declare } from "@babel/helper-plugin-utils";
+import transformReactJSX from "@babel/plugin-transform-react-jsx";
+import createReactJSXPlugin from "@babel/plugin-transform-react-jsx/lib/create-plugin";
+import transformReactDisplayName from "../../plugin/transform-react-display-name";
+import transformReactPure from "../../plugin/transform-react-pure-annotations";
+import normalizeOptions from "./normalize-options";
+export default declare((api, opts) => {
+    api.assertVersion("7");
+    const { development = api.env((env) => env === "development"), developmentSourceSelf, importSource, pragma, pragmaFrag, pure, runtime, throwIfNamespace, } = normalizeOptions(opts);
+    return {
+        visitor: {},
+        plugins: [
+            [
+                development
+                    ? createReactJSXPlugin({
+                        name: "transform-react-jsx/development",
+                        development: true,
+                        developmentSourceSelf,
+                    })
+                    : transformReactJSX,
+                {
+                    importSource,
+                    pragma,
+                    pragmaFrag,
+                    runtime,
+                    throwIfNamespace,
+                    pure,
+                },
+            ],
+            transformReactDisplayName,
+            pure !== false && transformReactPure,
+        ].filter(Boolean),
+    };
+});

package/dist/preset/react/normalize-options.d.ts

@@ -0,0 +1,10 @@
+export default function normalizeOptions(options?: any): {
+    development: boolean;
+    developmentSourceSelf: boolean;
+    importSource: string;
+    pragma: string;
+    pragmaFrag: string;
+    pure: boolean;
+    runtime: string;
+    throwIfNamespace: boolean;
+};

package/dist/preset/react/normalize-options.js

@@ -0,0 +1,60 @@
+import { OptionValidator, findSuggestion } from "../../helper/validator-option";
+const v = new OptionValidator("@babel/preset-react");
+export default function normalizeOptions(options = {}) {
+    if ("useSpread" in options) {
+        throw new Error('@babel/preset-react: Since Babel 8, an inline object with spread elements is always used, and the "useSpread" option is no longer available. Please remove it from your config.');
+    }
+    if ("useBuiltIns" in options) {
+        const useBuiltInsFormatted = JSON.stringify(options.useBuiltIns);
+        throw new Error(`@babel/preset-react: Since "useBuiltIns" is removed in Babel 8, you can remove it from the config.
+- Babel 8 now transforms JSX spread to object spread. If you need to transpile object spread with
+\`useBuiltIns: ${useBuiltInsFormatted}\`, you can use the following config
+{
+  "plugins": [
+    ["@babel/plugin-transform-object-rest-spread", { "loose": true, "useBuiltIns": ${useBuiltInsFormatted} }]
+  ],
+  "presets": ["@babel/preset-react"]
+}`);
+    }
+    const TopLevelOptions = {
+        development: "development",
+        developmentSourceSelf: "developmentSourceSelf",
+        importSource: "importSource",
+        pragma: "pragma",
+        pragmaFrag: "pragmaFrag",
+        pure: "pure",
+        runtime: "runtime",
+        throwIfNamespace: "throwIfNamespace",
+    };
+    v.validateTopLevelOptions(options, TopLevelOptions);
+    const development = v.validateBooleanOption(TopLevelOptions.development, options.development);
+    const developmentSourceSelf = v.validateBooleanOption(TopLevelOptions.developmentSourceSelf, options.developmentSourceSelf, false);
+    let importSource = v.validateStringOption(TopLevelOptions.importSource, options.importSource);
+    let pragma = v.validateStringOption(TopLevelOptions.pragma, options.pragma);
+    let pragmaFrag = v.validateStringOption(TopLevelOptions.pragmaFrag, options.pragmaFrag);
+    const pure = v.validateBooleanOption(TopLevelOptions.pure, options.pure);
+    const runtime = v.validateStringOption(TopLevelOptions.runtime, options.runtime, "automatic");
+    const throwIfNamespace = v.validateBooleanOption(TopLevelOptions.throwIfNamespace, options.throwIfNamespace, true);
+    const validRuntime = ["classic", "automatic"];
+    if (runtime === "classic") {
+        pragma = pragma || "React.createElement";
+        pragmaFrag = pragmaFrag || "React.Fragment";
+    }
+    else if (runtime === "automatic") {
+        importSource = importSource || "react";
+    }
+    else {
+        throw new Error(`@babel/preset-react: 'runtime' must be one of ['automatic', 'classic'] but we have '${runtime}'\n` +
+            `- Did you mean '${findSuggestion(runtime, validRuntime)}'?`);
+    }
+    return {
+        development,
+        developmentSourceSelf,
+        importSource,
+        pragma,
+        pragmaFrag,
+        pure,
+        runtime,
+        throwIfNamespace,
+    };
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@ssets/babel",
+  "version": "1.0.0",
+  "description": "Babel for SSE SSE UI Builder",
+  "type": "module",
+  "exports": {
+    "./plugin/*": {
+      "import": "./dist/plugin/*.js",
+      "types": "./dist/plugin/*.d.ts"
+    },
+    "./preset/*": {
+      "import": "./dist/preset/*.js",
+      "types": "./dist/preset/*.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
+  },
+  "author": "SSE Official",
+  "license": "MIT",
+  "dependencies": {
+    "@babel/core": "^7.29.0",
+    "@babel/helper-plugin-utils": "^7.28.6",
+    "@babel/plugin-transform-react-jsx": "^7.28.6",
+    "@babel/plugin-transform-runtime": "^7.29.0",
+    "@babel/preset-env": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "@types/babel__plugin-transform-runtime": "^7.9.5",
+    "@types/babel__preset-env": "^7.10.0",
+    "babel-plugin-transform-remove-imports": "^1.8.1",
+    "resolve": "^1.22.11"
+  },
+  "devDependencies": {
+    "@types/babel__helper-plugin-utils": "^7.10.3"
+  }
+}