@reframejs/unframer 4.2.0-reframe.0

package/dist/babel-jsx.js

@@ -0,0 +1,299 @@
+const noContainerTypes = new Set([
+    'JSXElement',
+    // 'StringLiteral',
+    'NumericLiteral',
+]);
+export function removeJsxExpressionContainer({ types: t, }) {
+    const plugin = {
+        name: 'remove-jsx-expression-container',
+        visitor: {
+            JSXExpressionContainer: {
+                exit(path) {
+                    const expr = path.node.expression;
+                    const parent = path.parentPath;
+                    const isChildren = parent &&
+                        parent.isJSXElement() &&
+                        Array.isArray(parent.node?.children) &&
+                        parent.node?.children?.includes(path.node);
+                    if (!isChildren) {
+                        return;
+                    }
+                    if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
+                        path.replaceWith(expr);
+                    }
+                    else if (t.isArrayExpression(expr)) {
+                        // Check if array contains only JSX elements/fragments
+                        const allJsx = expr.elements.every((element) => element &&
+                            (t.isJSXElement(element) ||
+                                t.isJSXFragment(element)));
+                        if (allJsx && 'elements' in expr && expr.elements) {
+                            try {
+                                const fragment = {
+                                    type: 'JSXFragment',
+                                    openingFragment: {
+                                        type: 'JSXOpeningFragment',
+                                    },
+                                    closingFragment: {
+                                        type: 'JSXClosingFragment',
+                                    },
+                                    children: expr.elements.filter(isTruthy),
+                                };
+                                path.replaceWith(fragment);
+                            }
+                            catch (e) {
+                                console.error(`cannot remove expression container for`, expr, e);
+                            }
+                        }
+                    }
+                },
+            },
+        },
+    };
+    return plugin;
+}
+function isTruthy(value) {
+    return value != null;
+}
+export function babelPluginJsxTransform({ types: t, }) {
+    const jsxFunctions = new Set();
+    return {
+        name: 'jsx-transform',
+        visitor: {
+            ImportDeclaration(path) {
+                const source = path.node.source.value;
+                // Track React JSX runtime imports
+                if (source === 'react/jsx-runtime' ||
+                    source === 'react/jsx-dev-runtime') {
+                    path.node.specifiers.forEach((specifier) => {
+                        if (t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported)) {
+                            const importName = specifier.imported.name;
+                            const localName = specifier.local.name;
+                            // Track common JSX runtime functions
+                            if (importName === 'jsx' ||
+                                importName === 'jsxs' ||
+                                importName === 'Fragment') {
+                                jsxFunctions.add(localName);
+                            }
+                        }
+                    });
+                }
+                // Track React imports that could be JSX functions
+                if (source === 'react') {
+                    path.node.specifiers.forEach((specifier) => {
+                        if (t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported)) {
+                            const importName = specifier.imported.name;
+                            const localName = specifier.local.name;
+                            // Track createElement and other JSX-related functions
+                            if (importName === 'createElement' ||
+                                importName === 'Fragment') {
+                                jsxFunctions.add(localName);
+                            }
+                        }
+                    });
+                }
+            },
+            CallExpression(path) {
+                // Check if it's a JSX function call
+                if (!path.node.callee ||
+                    !path.node.callee.name ||
+                    !jsxFunctions.has(path.node.callee.name)) {
+                    return;
+                }
+                // Remove /* @__PURE__ */ comments
+                if (path.node.leadingComments) {
+                    path.node.leadingComments =
+                        path.node.leadingComments.filter((comment) => !comment.value.includes('@__PURE__'));
+                }
+                const [elementArg, propsArg] = path.node.arguments;
+                // Get the element type name
+                let elementName = '';
+                if (elementArg.type === 'MemberExpression') {
+                    elementName = `${elementArg.object.name}.${elementArg.property.name}`;
+                }
+                else if (elementArg.type === 'StringLiteral') {
+                    elementName = elementArg.value;
+                }
+                else if (elementArg.type === 'Identifier') {
+                    if (!canRenderAsJsx(elementArg.name)) {
+                        return;
+                    }
+                    elementName = elementArg.name;
+                }
+                else {
+                    // Skip if we can't determine element name
+                    return;
+                }
+                // Convert to JSX element
+                const jsxElement = {
+                    type: 'JSXElement',
+                    openingElement: {
+                        type: 'JSXOpeningElement',
+                        name: {
+                            type: 'JSXIdentifier',
+                            name: elementName,
+                        },
+                        attributes: [],
+                        selfClosing: !propsArg.properties?.find((p) => p.key?.name === 'children'),
+                    },
+                    closingElement: propsArg.properties?.find((p) => p.key?.name === 'children')
+                        ? {
+                            type: 'JSXClosingElement',
+                            name: {
+                                type: 'JSXIdentifier',
+                                name: elementName,
+                            },
+                        }
+                        : null,
+                    children: [],
+                };
+                // Add attributes
+                if (propsArg && propsArg.properties) {
+                    propsArg.properties.forEach((prop) => {
+                        if (prop.type === 'SpreadElement') {
+                            jsxElement.openingElement.attributes.push({
+                                type: 'JSXSpreadAttribute',
+                                argument: prop.argument,
+                            });
+                        }
+                        else if (prop.key?.name === 'children') {
+                            if (prop.value.type === 'ArrayExpression') {
+                                jsxElement.children = prop.value.elements.map((element) => {
+                                    if (noContainerTypes.has(element.type)) {
+                                        return element;
+                                    }
+                                    return {
+                                        type: 'JSXExpressionContainer',
+                                        expression: element,
+                                    };
+                                });
+                            }
+                            else {
+                                if (noContainerTypes.has(prop.value.type)) {
+                                    jsxElement.children = [prop.value];
+                                }
+                                else {
+                                    jsxElement.children = [
+                                        {
+                                            type: 'JSXExpressionContainer',
+                                            expression: prop.value,
+                                        },
+                                    ];
+                                }
+                            }
+                        }
+                        else {
+                            let attrName = prop.key?.name;
+                            if (!attrName &&
+                                prop.key?.type === 'StringLiteral') {
+                                attrName = prop.key.value;
+                            }
+                            if (!attrName) {
+                                console.log(`no prop.key?.name for ${JSON.stringify(prop)}`);
+                                return;
+                            }
+                            jsxElement.openingElement.attributes.push({
+                                type: 'JSXAttribute',
+                                name: {
+                                    type: 'JSXIdentifier',
+                                    name: attrName,
+                                },
+                                value: {
+                                    type: 'JSXExpressionContainer',
+                                    expression: prop.value,
+                                },
+                            });
+                        }
+                    });
+                }
+                path.replaceWith(jsxElement);
+            },
+        },
+    };
+}
+function jsonStringifyWithMaps(map) {
+    return JSON.stringify([...map], (key, value) => (value instanceof Map ? [...value] : value), 2);
+}
+function canRenderAsJsx(name) {
+    // 1. Valid JS identifier?
+    const isIdentifier = /^[$A-Za-z_][$\w]*$/.test(name);
+    if (!isIdentifier)
+        return false;
+    // 2. First char not lowercase letter?
+    const first = name[0];
+    return first.toUpperCase() === first;
+}
+/**
+ * Injects `suppressHydrationWarning: true` into _jsx/_jsxs call props for elements
+ * that support it: lowercase HTML elements (div, span, etc.) and motion.* components.
+ * This prevents React hydration mismatch warnings caused by Framer's runtime rendering
+ * differently on server vs client (e.g. motion.div with layoutId, SVG containers, style attributes).
+ */
+export function babelPluginSuppressHydration({ types: t, }) {
+    const jsxFunctions = new Set();
+    const fragmentNames = new Set();
+    return {
+        name: 'suppress-hydration-warning',
+        visitor: {
+            ImportDeclaration(path) {
+                const source = path.node.source.value;
+                if (source === 'react/jsx-runtime' ||
+                    source === 'react/jsx-dev-runtime') {
+                    for (const specifier of path.node.specifiers) {
+                        if (t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported)) {
+                            if (specifier.imported.name === 'jsx' ||
+                                specifier.imported.name === 'jsxs') {
+                                jsxFunctions.add(specifier.local.name);
+                            }
+                            if (specifier.imported.name === 'Fragment') {
+                                fragmentNames.add(specifier.local.name);
+                            }
+                        }
+                    }
+                }
+                if (source === 'react') {
+                    for (const specifier of path.node.specifiers) {
+                        if (t.isImportSpecifier(specifier) &&
+                            t.isIdentifier(specifier.imported) &&
+                            specifier.imported.name === 'Fragment') {
+                            fragmentNames.add(specifier.local.name);
+                        }
+                    }
+                }
+            },
+            CallExpression(path) {
+                if (!t.isIdentifier(path.node.callee) ||
+                    !jsxFunctions.has(path.node.callee.name)) {
+                    return;
+                }
+                const [elementArg, propsArg] = path.node.arguments;
+                if (!propsArg || !t.isObjectExpression(propsArg)) {
+                    return;
+                }
+                // Skip React.Fragment — it only accepts key and children props.
+                // Handles both `Fragment` (Identifier) and `React.Fragment` (MemberExpression).
+                if (t.isIdentifier(elementArg) && fragmentNames.has(elementArg.name)) {
+                    return;
+                }
+                if (t.isMemberExpression(elementArg) &&
+                    t.isIdentifier(elementArg.property) &&
+                    elementArg.property.name === 'Fragment') {
+                    return;
+                }
+                // Skip if suppressHydrationWarning is already present
+                const alreadyHas = propsArg.properties.some((prop) => {
+                    return (t.isObjectProperty(prop) &&
+                        t.isIdentifier(prop.key) &&
+                        prop.key.name === 'suppressHydrationWarning');
+                });
+                if (alreadyHas) {
+                    return;
+                }
+                propsArg.properties.unshift(t.objectProperty(t.identifier('suppressHydrationWarning'), t.booleanLiteral(true)));
+            },
+        },
+    };
+}
+//# sourceMappingURL=babel-jsx.js.map

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

@@ -0,0 +1,15 @@
+import * as BabelTypes from '@babel/types';
+import { PluginObj } from '@babel/core';
+export declare function babelPluginDeduplicateImports({ types: t }: {
+    types: typeof BabelTypes;
+}): PluginObj;
+export declare function babelPluginRenameExports({ map }: {
+    map: Map<string, string>;
+}): {
+    name: string;
+    visitor: {
+        ExportNamedDeclaration(path: any): void;
+        ExportDefaultDeclaration(path: any): void;
+    };
+};
+//# sourceMappingURL=babel-plugin-imports.d.ts.map

package/dist/babel-plugin-imports.js

@@ -0,0 +1,211 @@
+import * as BabelTypes from '@babel/types';
+import BatchRenamer from './renamer.js';
+export function babelPluginDeduplicateImports({ types: t, }) {
+    const importAliasMap = new Map();
+    function addImport({ source, local, consolidated, importName, path, }) {
+        if (!importAliasMap.has(source)) {
+            importAliasMap.set(source, new Map());
+        }
+        importAliasMap
+            .get(source)
+            ?.set(local, { consolidated, importName, path, source });
+    }
+    function getConsolidatedName({ source, importName, defaultOne }) {
+        const allSpecifiers = [...importAliasMap.values()].flatMap((x) => [
+            ...x.values(),
+        ]);
+        const first = allSpecifiers.find((x) => {
+            if (importName === 'default' || importName === 'namespace') {
+                if (source !== x.source) {
+                    return false;
+                }
+            }
+            return x.importName === importName;
+        });
+        return first?.consolidated || defaultOne;
+    }
+    return {
+        visitor: {
+            ImportDeclaration(path) {
+                const source = path.node.source.value;
+                path.node.specifiers.forEach((specifier) => {
+                    if (t.isImportSpecifier(specifier) &&
+                        BabelTypes.isIdentifier(specifier.imported)) {
+                        const importName = specifier.imported.name;
+                        const consolidatedName = getConsolidatedName({
+                            source,
+                            importName,
+                            defaultOne: specifier.local.name,
+                        });
+                        addImport({
+                            source,
+                            local: specifier.local.name,
+                            importName,
+                            consolidated: consolidatedName,
+                            path,
+                        });
+                    }
+                    else if (t.isImportDefaultSpecifier(specifier)) {
+                        const importName = 'default';
+                        const consolidatedName = getConsolidatedName({
+                            source,
+                            importName,
+                            defaultOne: specifier.local.name,
+                        });
+                        addImport({
+                            source,
+                            local: specifier.local.name,
+                            importName,
+                            consolidated: consolidatedName,
+                            path,
+                        });
+                    }
+                    else if (t.isImportNamespaceSpecifier(specifier)) {
+                        const importName = 'namespace';
+                        const consolidatedName = getConsolidatedName({
+                            source,
+                            importName,
+                            defaultOne: specifier.local.name,
+                        });
+                        addImport({
+                            source,
+                            local: specifier.local.name,
+                            importName,
+                            consolidated: consolidatedName,
+                            path,
+                        });
+                    }
+                });
+                // Remove the current import declaration to later add the consolidated one
+                // path.remove()
+            },
+            Program: {
+                exit(path) {
+                    // console.log(`renaming imports...`)
+                    for (const [source, modMap] of importAliasMap) {
+                        // rename import names to consolidated names
+                        for (let [local, { consolidated, path: p }] of modMap) {
+                            // logger.log(
+                            //     `renaming ${local} to ${consolidated}...`,
+                            // )
+                        }
+                    }
+                    const map = new Map([...importAliasMap.values()].flatMap((x) => {
+                        return [...x.entries()]
+                            .map(([prev, x]) => {
+                            if (prev === x.consolidated) {
+                                return;
+                            }
+                            return [prev, x.consolidated];
+                        })
+                            .filter((x) => x !== undefined);
+                    }));
+                    // console.log([...map.entries()])
+                    const renamer = new BatchRenamer(path.scope, map);
+                    renamer.rename();
+                    const importDecs = path.node.body.filter((node) => t.isImportDeclaration(node));
+                    const definedImports = new Set();
+                    const later = [];
+                    // console.log(`removing duplicates...`)
+                    for (let importDec of importDecs) {
+                        const source = importDec.source.value;
+                        const specifiers = importDec.specifiers;
+                        for (let specifier of specifiers) {
+                            if (!BabelTypes.isImportSpecifier(specifier) &&
+                                !BabelTypes.isImportDefaultSpecifier(specifier) &&
+                                !BabelTypes.isImportNamespaceSpecifier(specifier)) {
+                                continue;
+                            }
+                            let importKey = '';
+                            if (BabelTypes.isImportDefaultSpecifier(specifier)) {
+                                importKey = source + 'default';
+                            }
+                            else if (BabelTypes.isImportNamespaceSpecifier(specifier)) {
+                                importKey = source + 'namespace';
+                            }
+                            else {
+                                if (!BabelTypes.isIdentifier(specifier.imported)) {
+                                    continue;
+                                }
+                                importKey = specifier.imported.name;
+                            }
+                            if (definedImports.has(importKey)) {
+                                later.push(() => {
+                                    // console.log(
+                                    //     `removing ${importKey} from ${source}...`,
+                                    // )
+                                    importDec.specifiers =
+                                        importDec.specifiers.filter((x) => x !== specifier);
+                                    if (!importDec.specifiers.length) {
+                                        const index = path.node.body.findIndex((x) => x === importDec);
+                                        path.node.body.splice(index, 1);
+                                    }
+                                });
+                            }
+                            definedImports.add(importKey);
+                        }
+                    }
+                    for (let fn of later) {
+                        fn();
+                    }
+                },
+            },
+            // Identifier(path) {
+            //     const name = path.node.name
+            //     const binding = path.scope.getBinding(name)
+            //     if (binding && t.isImportSpecifier(binding.path.node)) {
+            //         const source = (binding.path.parent as ImportDeclaration)
+            //             .source.value
+            //         const localName = getLocalImportName(source, name)
+            //         if (localName && localName !== name) {
+            //             path.node.name = localName
+            //         }
+            //     }
+            // },
+        },
+    };
+}
+export function babelPluginRenameExports({ map, }) {
+    return {
+        name: 'rename-exports',
+        visitor: {
+            ExportNamedDeclaration(path) {
+                const { specifiers, declaration } = path.node;
+                // Handle export specifiers like: export { something as oldName }
+                for (const specifier of specifiers) {
+                    if (!BabelTypes.isExportSpecifier(specifier))
+                        continue;
+                    const exported = specifier.exported;
+                    if (!BabelTypes.isIdentifier(exported))
+                        continue;
+                    const oldName = exported.name;
+                    const newName = map.get(oldName);
+                    if (newName) {
+                        exported.name = newName;
+                    }
+                }
+                // Handle function declarations like: export function oldName1() {}
+                if (BabelTypes.isFunctionDeclaration(declaration)) {
+                    const oldName = declaration.id?.name;
+                    if (oldName) {
+                        const newName = map.get(oldName);
+                        if (newName && declaration?.id) {
+                            declaration.id.name = newName;
+                        }
+                    }
+                }
+            },
+            ExportDefaultDeclaration(path) {
+                const { declaration } = path.node;
+                if (BabelTypes.isIdentifier(declaration)) {
+                    const oldName = declaration.name;
+                    const newName = map.get(oldName);
+                    if (newName) {
+                        declaration.name = newName;
+                    }
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=babel-plugin-imports.js.map

package/dist/babel-typedoc.d.ts

@@ -0,0 +1,39 @@
+import type { PluginObj } from '@babel/core';
+import type * as BabelTypes from '@babel/types';
+/**
+ * Babel plugin that injects typed-documentation (typedoc/JSDoc) comments into the
+ * generated JSX files.
+ *
+ * The plugin receives, via its options, the comment blocks that must be added
+ * and places them in three different locations:
+ *
+ *   1. `headerComment` – added **once** at the very top of the file, right after
+ *      any `"use client"` / `"use strict"` (directive literals) that may be
+ *      present.
+ *   2. `responsiveComment` – added immediately **before** the statement that
+ *      assigns to the `.Responsive` static member (i.e.
+ *      `Component.Responsive = …`).
+ *   3. `defaultExportComment` – added **before** the default export declaration
+ *      so that the exported value bears the correct `@type` annotation.
+ *
+ * The actual _content_ of the comments is produced elsewhere
+ * (in the logic that previously generated `.d.ts` files) and handed to this
+ * plugin through its options, therefore the plugin only concerns itself with
+ * finding the right AST nodes and attaching the supplied comments.
+ *
+ * Because this file lives in `src/`, it is written in ESM and must be imported
+ * with the `.js` extension once transpiled.
+ */
+interface InjectTypedocOptions {
+    /** Complete comment block, e.g. `/** … *\/`  */
+    headerComment: string;
+    /** `/** … *\/` that documents the `.Responsive` member. Optional. */
+    responsiveComment?: string;
+    /** `/** … *\/` for the default export. Optional. */
+    defaultExportComment?: string;
+}
+export declare function babelPluginTypedoc(options: InjectTypedocOptions): ({ types: t }: {
+    types: typeof BabelTypes;
+}) => PluginObj<import("@babel/core").PluginPass>;
+export {};
+//# sourceMappingURL=babel-typedoc.d.ts.map

package/dist/babel-typedoc.js

@@ -0,0 +1,76 @@
+function toBlockComment(value) {
+    // Ensure we only keep the contents between /** and */
+    const cleaned = value
+        .trim()
+        // drop beginning "/**" (with optional extra *) and any leading whitespace
+        .replace(/^\/\*\*+/, '')
+        // drop ending "*/"
+        .replace(/\*\/$/, '');
+    // We deliberately keep the leading '*' characters in each line so Babel
+    // prints "/** … */" instead of "/* … */".
+    // Add a leading asterisk if none exists to ensure JSDoc-style comments
+    const withLeadingAsterisk = cleaned.startsWith('*')
+        ? cleaned
+        : '*' + cleaned;
+    return {
+        type: 'CommentBlock',
+        value: withLeadingAsterisk,
+    };
+}
+export function babelPluginTypedoc(options) {
+    return function ({ types: t }) {
+        const { headerComment, responsiveComment, defaultExportComment } = options;
+        return {
+            name: 'inject-typedoc-comments',
+            visitor: {
+                Program: {
+                    enter(path) {
+                        if (!headerComment)
+                            return;
+                        const comment = toBlockComment(headerComment);
+                        const body = path.node.body;
+                        // Find the first non-directive statement. Directives are
+                        // ExpressionStatements whose expression is a
+                        // StringLiteral and which are placed at the top.
+                        const firstNonDirective = body.find((stmt) => !(t.isExpressionStatement(stmt) &&
+                            t.isStringLiteral(stmt.expression)));
+                        if (firstNonDirective) {
+                            firstNonDirective.leadingComments = (firstNonDirective.leadingComments || []).concat(comment);
+                        }
+                        else if (body.length) {
+                            // Fallback – attach to the very first node
+                            body[0].leadingComments = (body[0].leadingComments || []).concat(comment);
+                        }
+                        else {
+                            // Empty file (unlikely) – create an empty statement
+                            const empty = t.emptyStatement();
+                            empty.leadingComments = [comment];
+                            body.push(empty);
+                        }
+                    },
+                },
+                ExpressionStatement(path) {
+                    if (!responsiveComment)
+                        return;
+                    const expr = path.node.expression;
+                    if (t.isAssignmentExpression(expr) &&
+                        t.isMemberExpression(expr.left) &&
+                        !expr.left.computed &&
+                        t.isIdentifier(expr.left.property) &&
+                        expr.left.property.name === 'Responsive') {
+                        path.node.leadingComments = (path.node.leadingComments || []).concat(toBlockComment(responsiveComment));
+                    }
+                },
+                FunctionDeclaration(path) {
+                    if (!defaultExportComment)
+                        return;
+                    // Look for ComponentWithRoot function declaration
+                    if (path.node.id?.name === 'ComponentWithRoot') {
+                        path.node.leadingComments = (path.node.leadingComments || []).concat(toBlockComment(defaultExportComment));
+                    }
+                },
+            },
+        };
+    };
+}
+//# sourceMappingURL=babel-typedoc.js.map

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.js

@@ -0,0 +1,3 @@
+import { cli } from "./cli.js";
+cli.parse();
+//# sourceMappingURL=bin.js.map