nexa-compiler 0.7.11 → 0.8.1

package/dist/codegen/render.js

@@ -24,13 +24,10 @@ export function generateComponentCode(sfc, filename) {
                 // Only add Teleport/Transition if they are used in template (keeping it simple for tests)
                 const hasTeleport = sfc.template?.includes('<Teleport');
                 const hasTransition = sfc.template?.includes('<Transition');
-                const hasVCurrency = sfc.template?.includes('v-currency');
                 if (hasTeleport && !existing.includes('Teleport'))
                     needed.push('Teleport');
                 if (hasTransition && !existing.includes('Transition'))
                     needed.push('Transition');
-                if (hasVCurrency && !existing.includes('vCurrency'))
-                    needed.push('vCurrency');
                 if (needed.length > 0) {
                     const merged = [...existing, ...needed].join(', ');
                     lines.push(imp.replace(/\{[^}]+\}/s, `{ ${merged} }`));
@@ -54,8 +51,6 @@ export function generateComponentCode(sfc, filename) {
             defaultImports.push('Teleport');
         if (sfc.template?.includes('<Transition'))
             defaultImports.push('Transition');
-        if (sfc.template?.includes('v-currency'))
-            defaultImports.push('vCurrency');
         lines.push(`import { ${defaultImports.join(', ')} } from 'nexa-framework'`);
     }
     const { scopeId, styleCode } = transformStyle(sfc.style, sfc.scoped, sfc.template);
@@ -70,7 +65,7 @@ export function generateComponentCode(sfc, filename) {
         const emitsDef = parseDefineEmits(fullScript);
         const cleanSetup = stripMacroLines(fullScript);
         const scriptBindings = extractBindings(cleanSetup);
-        const importBindings = extractImportBindings(importLines).filter(b => !['h', 'hText', 'effect', 'defineComponent', 'registerComponent', 'reloadComponent', 'injectStyle', 'signal', 'computed', 'watch', 'onMounted', 'onUnmounted', 'Teleport', 'Transition', 'vCurrency'].includes(b));
+        const importBindings = extractImportBindings(importLines).filter(b => !['h', 'hText', 'effect', 'defineComponent', 'registerComponent', 'reloadComponent', 'injectStyle', 'signal', 'computed', 'watch', 'onMounted', 'onUnmounted', 'Teleport', 'Transition'].includes(b));
         if (propsDef) {
             if (!propsDef._isJS) {
                 propsKeys = Object.keys(propsDef);

package/dist/codegen/template.js

@@ -50,7 +50,14 @@ function genForIterate(list, item, index, body) {
 }
 function genElement(node) {
     const { tag, props, children } = node;
-    const childStr = genChildren(children);
+    const isComponent = /^[A-Z]/.test(tag) || ['Teleport', 'Transition', 'Fragment'].includes(tag);
+    if (isComponent && children && children.length > 0) {
+        const slotChildren = children.filter(c => c.type === 'element' && c.slotName);
+        if (slotChildren.length > 0) {
+            return genElementWithSlots(node);
+        }
+    }
+    const childStr = genChildrenSimple(children);
     const elementCode = buildElementCode(tag, props, childStr, node.scopeId);
     if (node.vFor) {
         const { item, index, list } = node.vFor;
@@ -59,6 +66,54 @@ function genElement(node) {
     // Note: v-if is handled by transformChildren and genIf
     return elementCode;
 }
+function genElementWithSlots(node) {
+    const { tag, props, children } = node;
+    const isComponent = /^[A-Z]/.test(tag) || ['Teleport', 'Transition', 'Fragment'].includes(tag);
+    const tagCode = isComponent ? `_ntc_${tag}` : `'${tag}'`;
+    let finalProps = props;
+    if (node.scopeId) {
+        const scopeProp = `"${node.scopeId}": ""`;
+        finalProps = props ? `${props}, ${scopeProp}` : scopeProp;
+    }
+    const slotObj = genSlotObject(children);
+    let elementCode;
+    if (finalProps) {
+        elementCode = `h(${tagCode}, { ${finalProps} }, {\n        ${slotObj}\n      })`;
+    }
+    else {
+        elementCode = `h(${tagCode}, null, {\n        ${slotObj}\n      })`;
+    }
+    if (node.vFor) {
+        const { item, index, list } = node.vFor;
+        return genForIterate(list, item, index, elementCode);
+    }
+    return elementCode;
+}
+function genSlotObject(children) {
+    const entries = [];
+    const regularChildren = [];
+    for (const child of children) {
+        if (child.type === 'element' && child.slotName) {
+            const el = child;
+            const name = el.slotName;
+            const key = /^[\w$]+$/.test(name) ? name : JSON.stringify(name);
+            const args = el.slotProps ? `(${el.slotProps})` : '()';
+            const childCode = el.children && el.children.length > 0
+                ? el.children.map(c => genNode(c)).join(',\n          ')
+                : '';
+            const body = childCode ? `[\n          ${childCode}\n        ]` : 'null';
+            entries.push(`${key}: ${args} => ${body}`);
+        }
+        else {
+            regularChildren.push(child);
+        }
+    }
+    if (regularChildren.length > 0) {
+        const defaultCode = regularChildren.map(c => genNode(c)).join(',\n        ');
+        entries.push(`default: () => [\n        ${defaultCode}\n      ]`);
+    }
+    return entries.join(',\n        ');
+}
 function buildElementCode(tag, propStr, childStr, scopeId) {
     const isComponent = /^[A-Z]/.test(tag) || ['Teleport', 'Transition', 'Fragment'].includes(tag);
     const tagCode = isComponent ? `_ntc_${tag}` : `'${tag}'`;
@@ -78,7 +133,7 @@ function buildElementCode(tag, propStr, childStr, scopeId) {
     }
     return `h(${tagCode})`;
 }
-function genChildren(children) {
+function genChildrenSimple(children) {
     if (!children || children.length === 0)
         return '';
     return children.map(child => genNode(child)).join(',\n        ');

package/dist/parse/template.js

@@ -150,7 +150,11 @@ function parseAttrs(attrsStr, template, tagStart) {
         }
         else if (rawName.startsWith('#')) {
             name = 'slot';
+            const slotPropsValue = quotedValue;
             quotedValue = rawName.slice(1);
+            if (slotPropsValue !== undefined && slotPropsValue !== quotedValue) {
+                attrs.push({ name: 'slotProps', value: slotPropsValue, dynamic: true });
+            }
         }
         else {
             name = rawName;

package/dist/transform/template.d.ts

@@ -15,6 +15,8 @@ export type TransformedNode = {
         list: string;
     };
     scopeId?: string;
+    slotName?: string;
+    slotProps?: string;
 } | {
     type: 'text';
     content: string;

package/dist/transform/template.js

@@ -12,11 +12,11 @@ function transformNode(node, scopeId) {
                 const slotProps = dynamicAttrs.length > 0
                     ? dynamicAttrs.map(a => `${a.name}: ${a.value}`).join(', ')
                     : undefined;
-                return { type: 'slot', name: node.attrs.find(a => a.name === 'name')?.value || 'default', slotProps, children: node.children?.map(c => transformNode(c, scopeId)) };
+                return { type: 'slot', name: node.attrs.find(a => a.name === 'name')?.value || 'default', slotProps, children: node.children?.map(c => transformNode(c)) };
             }
             const vForAttr = node.attrs.find(a => a.name === 'v-for');
             const vIfAttr = node.attrs.find(a => a.name === 'v-if');
-            const filteredAttrs = node.attrs.filter(a => a.name !== 'v-if' && a.name !== 'v-for');
+            const filteredAttrs = node.attrs.filter(a => a.name !== 'v-if' && a.name !== 'v-for' && a.name !== 'slot' && a.name !== 'slotProps');
             const props = genProps(filteredAttrs, node.tag);
             const result = {
                 type: 'element',
@@ -27,6 +27,14 @@ function transformNode(node, scopeId) {
             if (scopeId) {
                 result.scopeId = scopeId;
             }
+            const slotAttr = node.attrs.find(a => a.name === 'slot');
+            if (slotAttr && typeof slotAttr.value === 'string') {
+                result.slotName = slotAttr.value;
+            }
+            const slotPropsAttr = node.attrs.find(a => a.name === 'slotProps');
+            if (slotPropsAttr && typeof slotPropsAttr.value === 'string') {
+                result.slotProps = slotPropsAttr.value;
+            }
             if (vIfAttr && typeof vIfAttr.value === 'string') {
                 result.vIf = vIfAttr.value;
             }
@@ -43,7 +51,7 @@ function transformNode(node, scopeId) {
             const slotProps = dynamicAttrs.length > 0
                 ? dynamicAttrs.map(a => `${a.name}: ${a.value}`).join(', ')
                 : undefined;
-            return { type: 'slot', name: node.name, slotProps, children: node.children?.map(c => transformNode(c, scopeId)) };
+            return { type: 'slot', name: node.name, slotProps, children: node.children?.map(c => transformNode(c)) };
         }
         case 'if': {
             const then = transformChildren(node.then, scopeId);
@@ -138,9 +146,6 @@ function genProps(attrs, tag) {
         if (propName === 'vShow' && typeof attr.value === 'string') {
             parts.push(`${propName}: ${attr.value}`);
         }
-        else if (propName === 'vCurrency' && typeof attr.value === 'string') {
-            parts.push(`${propName}: ${attr.value}`);
-        }
         else if (propName === 'vModel' && typeof attr.value === 'string') {
             const isComponent = /^[A-Z]/.test(tag) || tag.includes('-');
             if (isComponent) {
@@ -157,20 +162,13 @@ function genProps(attrs, tag) {
             const realName = parts_name[0];
             const modifiers = parts_name.slice(1);
             let handler;
-            if (typeof attr.value === 'string' && /^\w+$/.test(attr.value)) {
-                handler = attr.value;
-            }
-            else if (typeof attr.value === 'string') {
-                const eqIdx = attr.value.indexOf('=');
-                if (eqIdx > 0) {
-                    const lhs = attr.value.slice(0, eqIdx).trim();
-                    const rhs = attr.value.slice(eqIdx + 1).trim();
-                    if (/^[a-zA-Z_$]\w*$/.test(lhs)) {
-                        handler = `($event) => { ${lhs}.value = ${rhs} }`;
-                    }
-                    else {
-                        handler = `($event) => { ${attr.value} }`;
-                    }
+            if (typeof attr.value === 'string') {
+                const assignMatch = attr.value.match(/^(\w+)\s*=\s*(.+)$/);
+                if (assignMatch) {
+                    handler = `($event) => { ${assignMatch[1]}.value = ${assignMatch[2]} }`;
+                }
+                else if (/^\w+$/.test(attr.value)) {
+                    handler = attr.value;
                 }
                 else {
                     handler = `($event) => { ${attr.value} }`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexa-compiler",
-  "version": "0.7.11",
+  "version": "0.8.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",