@motifx/compiler 1.2.0-rc.1 → 1.2.0-rc.3

package/README.md

@@ -18,11 +18,10 @@ import compiler from '@motifx/compiler';
 
 export default defineConfig({
     plugins: [compiler()],
-    esbuild: { jsx: 'preserve' },
 });
 ```
 
-Set `"jsx": "preserve"` in `tsconfig.json` as well, so that only `@motifx/compiler` compiles JSX. Vitest picks up the same plugin from the Vite config.
+The plugin runs before Vite's own transform (`enforce: 'pre'`) and leaves no JSX behind, so Vite needs no JSX setting. Set `"jsx": "preserve"` in `tsconfig.json` so that TypeScript type-checks JSX without compiling it. Vitest picks up the same plugin from the Vite config.
 
 ## Rollup
 

package/dist/index.cjs

@@ -457,7 +457,7 @@ const motifComponent = () => { return "_mc"; };
 const motifFragment = () => { return "_mf"; };
 const motifFunctionComponent = () => { return "_mfc"; };
 const motifCompiled = () => { return "_mv"; };
-const COMPILER_CONTRACT = 1;
+const COMPILER_CONTRACT = 2;
 
 let active$1 = null;
 let seen = null;
@@ -2954,16 +2954,63 @@ function injectDeclaredElementTag(path) {
     }
     catch { /* enjeksiyon başarısızsa derleme bozulmasın */ }
 }
-const elementTagPlugin = () => ({
-    name: 'motifjs-element-tag',
-    visitor: {
-        Class: {
-            enter(path) {
-                injectDeclaredElementTag(path);
+const isThisChilds = (e) => !!e && t__namespace.isMemberExpression(e) && !e.computed && t__namespace.isThisExpression(e.object)
+    && t__namespace.isIdentifier(e.property) && e.property.name === 'childs';
+function placesChilds(path) {
+    let found = false;
+    path.traverse({
+        Class(inner) { inner.skip(); },
+        FunctionDeclaration(inner) { inner.skip(); },
+        FunctionExpression(inner) { inner.skip(); },
+        JSXExpressionContainer(slot) {
+            if (!t__namespace.isJSXElement(slot.parent) && !t__namespace.isJSXFragment(slot.parent))
+                return;
+            const e = slot.node.expression;
+            const value = t__namespace.isArrowFunctionExpression(e) && !t__namespace.isBlockStatement(e.body) ? e.body : e;
+            if (isThisChilds(value)) {
+                found = true;
+                slot.stop();
             }
         }
+    });
+    return found;
+}
+function injectChildsSlotMarker(path) {
+    try {
+        const node = path.node;
+        if (!node.superClass || hasStaticMember(node, '_placesChilds'))
+            return;
+        if (!placesChilds(path))
+            return;
+        node.body.body.unshift(t__namespace.classProperty(t__namespace.identifier('_placesChilds'), t__namespace.booleanLiteral(true), null, null, false, true));
     }
-});
+    catch { }
+}
+const isTypeOnlyField = (member) => t__namespace.isClassProperty(member) && (!!member.declare || !!member.abstract);
+function stripTypeOnlyFields(path) {
+    const body = path.node.body.body;
+    if (!body.some(isTypeOnlyField))
+        return;
+    path.node.body.body = body.filter(member => !isTypeOnlyField(member));
+}
+const elementTagPlugin = () => {
+    const visited = new WeakSet();
+    return {
+        name: 'motifjs-element-tag',
+        visitor: {
+            Class: {
+                enter(path) {
+                    if (visited.has(path.node))
+                        return;
+                    visited.add(path.node);
+                    stripTypeOnlyFields(path);
+                    injectDeclaredElementTag(path);
+                    injectChildsSlotMarker(path);
+                }
+            }
+        }
+    };
+};
 class Compiler {
     motifCompile(code, filename) {
         return this.start(code, filename);
@@ -3134,6 +3181,22 @@ class Compiler {
                                         path.node.body = [...setOriginal, cls];
                                     }
                                     state.set('filename', filename);
+                                    path.traverse({
+                                        CallExpression(call) {
+                                            const node = call.node;
+                                            if (!t__namespace.isIdentifier(node.callee, { name: motifComponent() }) || node.arguments.length !== 2)
+                                                return;
+                                            const [tag, props] = node.arguments;
+                                            if (!t__namespace.isStringLiteral(tag) || !t__namespace.isObjectExpression(props) || props.properties.length !== 1)
+                                                return;
+                                            const only = props.properties[0];
+                                            if (!t__namespace.isObjectProperty(only) || only.computed || !t__namespace.isIdentifier(only.key, { name: 'initializeComponent' }))
+                                                return;
+                                            if (!t__namespace.isArrowFunctionExpression(only.value) && !t__namespace.isFunctionExpression(only.value))
+                                                return;
+                                            node.arguments[1] = only.value;
+                                        }
+                                    });
                                     absorbGeneratedCoreImports(topLevel, coreImports);
                                     if (coreImports.size > 0) {
                                         const contractCall = t__namespace.callExpression(t__namespace.identifier(motifCompiled()), [t__namespace.numericLiteral(COMPILER_CONTRACT)]);