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

package/dist/index.esm.js

@@ -430,7 +430,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;
@@ -2927,16 +2927,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.isMemberExpression(e) && !e.computed && t.isThisExpression(e.object)
+    && t.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.isJSXElement(slot.parent) && !t.isJSXFragment(slot.parent))
+                return;
+            const e = slot.node.expression;
+            const value = t.isArrowFunctionExpression(e) && !t.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.classProperty(t.identifier('_placesChilds'), t.booleanLiteral(true), null, null, false, true));
     }
-});
+    catch { }
+}
+const isTypeOnlyField = (member) => t.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);
@@ -3107,6 +3154,22 @@ class Compiler {
                                         path.node.body = [...setOriginal, cls];
                                     }
                                     state.set('filename', filename);
+                                    path.traverse({
+                                        CallExpression(call) {
+                                            const node = call.node;
+                                            if (!t.isIdentifier(node.callee, { name: motifComponent() }) || node.arguments.length !== 2)
+                                                return;
+                                            const [tag, props] = node.arguments;
+                                            if (!t.isStringLiteral(tag) || !t.isObjectExpression(props) || props.properties.length !== 1)
+                                                return;
+                                            const only = props.properties[0];
+                                            if (!t.isObjectProperty(only) || only.computed || !t.isIdentifier(only.key, { name: 'initializeComponent' }))
+                                                return;
+                                            if (!t.isArrowFunctionExpression(only.value) && !t.isFunctionExpression(only.value))
+                                                return;
+                                            node.arguments[1] = only.value;
+                                        }
+                                    });
                                     absorbGeneratedCoreImports(topLevel, coreImports);
                                     if (coreImports.size > 0) {
                                         const contractCall = t.callExpression(t.identifier(motifCompiled()), [t.numericLiteral(COMPILER_CONTRACT)]);