@mulanjs/mulanjs 1.0.1-dev.20260212143840

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 nitinkumardev09
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# mulanjs_framework

package/dist/compiler/compiler.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSFC = compileSFC;
+const sfc_parser_1 = require("./sfc-parser");
+const script_compiler_1 = require("./script-compiler");
+const template_compiler_1 = require("./template-compiler");
+const style_compiler_1 = require("./style-compiler");
+function compileSFC(source, filename) {
+    // 1. Parse
+    const descriptor = (0, sfc_parser_1.parseMUJS)(source, filename);
+    // 2. Script
+    const scriptResult = (0, script_compiler_1.compileScript)(descriptor);
+    // Replace export default to capture the component
+    let scriptCode = scriptResult.code.replace('export default', 'const __component__ =');
+    if (!scriptCode.includes('const __component__ =')) {
+        scriptCode = scriptCode.replace(/export\s+default/, 'const __component__ =');
+    }
+    // 3. Style
+    const styleResult = (0, style_compiler_1.compileStyle)(descriptor, filename);
+    // 4. Template
+    const templateResult = (0, template_compiler_1.compileTemplate)(descriptor, scriptResult, styleResult.scopedId);
+    // 5. Assembly
+    const cssInjection = styleResult.css ? `
+if (typeof document !== 'undefined') {
+    const style = document.createElement('style');
+    style.textContent = \`${styleResult.css}\`;
+    document.head.appendChild(style);
+}
+` : '';
+    const finalCode = `${scriptCode}
+
+${templateResult.code}
+
+// Attach template to component
+if (__component__.prototype) {
+    // Class component
+    __component__.prototype.template = render;
+} else if (typeof __component__ === 'object') {
+    // Options object
+    __component__.template = render;
+}
+
+${cssInjection}
+
+// --- MulanJS HMR Engine ---
+if (typeof module !== 'undefined' && module.hot) {
+    const hmrId = "${filename.replace(/\\/g, '/')}";
+    window.__MULAN_HMR__ = window.__MULAN_HMR__ || {
+        records: new Map(),
+        notify: (id, newComp) => {
+            const oldRecord = window.__MULAN_HMR__.records.get(id);
+            if (oldRecord) {
+                console.log('[MulanJS HMR] Patching:', id);
+                if (oldRecord.prototype && newComp.prototype) {
+                    oldRecord.prototype.template = newComp.prototype.template;
+                    // Also patch setup if available (for Functional components)
+                    if (newComp._setup) oldRecord._setup = newComp._setup;
+                } else {
+                    Object.assign(oldRecord, newComp);
+                }
+                if (window.__MULAN_REFRESH__) {
+                    console.log('[MulanJS HMR] Triggering Deep Refresh');
+                    window.__MULAN_REFRESH__();
+                }
+            }
+        }
+    };
+
+    if (window.__MULAN_HMR__.records.has(hmrId)) {
+        window.__MULAN_HMR__.notify(hmrId, __component__);
+    } else {
+        window.__MULAN_HMR__.records.set(hmrId, __component__);
+    }
+    module.hot.accept();
+}
+
+// console.log('[MulanJS] Component created:', __component__);
+export default __component__;
+
+// Helper to get relative path for sourceURL
+// This ensures the generated file appears in a readable folder structure in DevTools
+// SourceURL removed. Using standard Source Maps only.
+`;
+    return {
+        code: finalCode,
+        css: styleResult.css,
+        errors: [...scriptResult.errors, ...templateResult.errors],
+        map: scriptResult.map // Pass the map
+    };
+}

package/dist/compiler/script-compiler.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileScript = compileScript;
+const ts = __importStar(require("typescript"));
+function compileScript(descriptor) {
+    const script = descriptor.script;
+    if (!script)
+        return { code: 'export default {}', errors: [] };
+    const isSetup = !!script.attrs.setup;
+    const isTs = script.attrs.lang === 'ts' || script.attrs.lang === 'tsx';
+    if (isSetup) {
+        return compileSetupScript(script, isTs, descriptor);
+    }
+    else {
+        // Standard Options API - just pass through, assuming it has export default
+        return { code: script.content, errors: [] };
+    }
+}
+// Global list of Mulan hooks for auto-imports and reactivity exemption
+const COMMON_HOOKS = ['muState', 'onMuMount', 'onMuInit', 'onMuDestroy', 'muEffect', 'muMemo', 'muQubit', 'muGate', 'muMeasure', 'muRegister', 'muEntangle', 'persistent'];
+function compileSetupScript(script, isTs, descriptor) {
+    var _a;
+    // 1. Pre-process: Natural Reactivity Transformation ($ syntax)
+    // We do this BEFORE extraction so that the rest of the compiler sees standard 'muState' code.
+    const transformedContent = transformNaturalReactivity(script.content, isTs);
+    // 2. Parse the TRANSFORMED code
+    const sourceFile = ts.createSourceFile('script.' + (isTs ? 'ts' : 'js'), transformedContent, ts.ScriptTarget.Latest, true);
+    const imports = [];
+    const statements = [];
+    const bindings = [];
+    sourceFile.statements.forEach(stmt => {
+        if (ts.isImportDeclaration(stmt)) {
+            imports.push(transformedContent.substring(stmt.pos, stmt.end).trim());
+        }
+        else {
+            statements.push(transformedContent.substring(stmt.pos, stmt.end).trim());
+            // Extract top-level declarations for template exposure
+            if (ts.isVariableStatement(stmt)) {
+                stmt.declarationList.declarations.forEach(decl => {
+                    if (ts.isIdentifier(decl.name)) {
+                        bindings.push(decl.name.text);
+                    }
+                });
+            }
+            else if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+                bindings.push(stmt.name.text);
+            }
+            else if (ts.isClassDeclaration(stmt) && stmt.name) {
+                bindings.push(stmt.name.text);
+            }
+        }
+    });
+    // Reconstruct
+    // We import defineComponent from mulanjs if not present? 
+    // Ideally user imports what they need, but for 'setup' wrapping we need defineComponent.
+    // Let's assume user might not have imported it, so we import it as _defineComponent to avoid collision.
+    // Check if defineComponent is imported
+    const hasDefineComponent = imports.some(i => i.includes('defineComponent'));
+    const bootImports = hasDefineComponent ? '' : `import { defineComponent as _defineComponent } from 'mulanjs';`;
+    // ADDED: Check if we introduced 'muState' but it wasn't imported (because user used $)
+    const usesMuState = transformedContent.includes('muState');
+    const hasMuStateImport = imports.some(i => i.includes('muState') || i.includes('mulanjs'));
+    let autoImports = (usesMuState && !hasMuStateImport) ? [`muState`] : [];
+    // Auto-import common hooks
+    COMMON_HOOKS.forEach(hook => {
+        if (transformedContent.includes(hook) && !imports.some(i => i.includes(hook))) {
+            // Avoid duplicates in autoImports
+            if (!autoImports.includes(hook)) {
+                autoImports.push(hook);
+            }
+        }
+    });
+    const autoImportStmt = autoImports.length > 0
+        ? `import { ${autoImports.join(', ')} } from 'mulanjs';`
+        : '';
+    const filename = descriptor.filename;
+    const componentName = filename ? ((_a = filename.split(/[/\\]/).pop()) === null || _a === void 0 ? void 0 : _a.split('.')[0].replace(/\W/g, '')) || 'App' : 'App';
+    const bindingString = bindings.length > 0
+        ? `
+        const exposed = { ${bindings.join(', ')} };
+        if (typeof window !== 'undefined') {
+            window["${componentName}"] = exposed;
+        }
+        return exposed;
+        `
+        : 'return {};';
+    const finalCode = `
+${bootImports}
+${autoImportStmt}
+${imports.join('\n')}
+
+export default ${hasDefineComponent ? 'defineComponent' : '_defineComponent'}({
+    setup() {
+        ${statements.join('\n')}
+        ${bindingString}
+    }
+});
+    `;
+    if (isTs) {
+        // Calculate line offset for Source Maps (Padding Strategy)
+        // Find how many newlines are before the script content in the original source
+        // This is a rough estimation but better than nothing for 1.0 dev
+        const linesBefore = descriptor.source.substring(0, script.start).split('\n').length - 1;
+        const padding = '\n'.repeat(linesBefore);
+        // Pad the content so line numbers match original file
+        // Note: This only works perfectly if we are transpiling the RAW content.
+        // Since we are extracting/transforming (Natural Reactivity), line numbers might shift.
+        // For accurate 1-to-1 mapping, we rely on TS source maps of the 'finalCode'.
+        // To make 'finalCode' map back to 'filename', we need to construct it carefully.
+        // Transpile extracted TS code to JS
+        const result = ts.transpileModule(finalCode, {
+            compilerOptions: {
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.ES2019,
+                sourceMap: true, // ENABLE SOURCE MAPS
+                inlineSources: true,
+                sourceRoot: '/',
+            },
+            fileName: filename // Important for source map
+        });
+        // Fix: Remove the //# sourceMappingURL= comment added by TS
+        const codeWithoutMapComment = result.outputText.replace(/\/\/# sourceMappingURL=.*$/gm, '');
+        // Enhance Source Map to show ORIGINAL .mujs content
+        let finalMap = result.sourceMapText;
+        if (finalMap) {
+            try {
+                const mapObj = JSON.parse(finalMap);
+                // Try to get relative path from 'src' to preserve folder structure in DevTools
+                const normalizedPath = filename.replace(/\\/g, '/');
+                const srcIndex = normalizedPath.indexOf('/src/');
+                // If inside src, use path starting from src. Else just basename.
+                // Example: c:/.../src/pages/Home.mujs -> src/pages/Home.mujs
+                let relativePath = srcIndex !== -1
+                    ? normalizedPath.substring(srcIndex + 1)
+                    : filename.split(/[/\\]/).pop() || 'unknown.mujs';
+                // Use relative path directly. Webpack will handle the namespace.
+                mapObj.sources = [relativePath];
+                mapObj.sourcesContent = [descriptor.source];
+                finalMap = JSON.stringify(mapObj);
+            }
+            catch (e) {
+                console.warn('[MulanJS] Failed to patch source map:', e);
+            }
+        }
+        return {
+            code: codeWithoutMapComment,
+            bindings,
+            errors: [],
+            map: finalMap // Return the enhanced map
+        };
+    }
+    return {
+        code: finalCode,
+        bindings,
+        errors: [],
+        map: undefined
+    };
+}
+// --- Natural Reactivity Transformer ---
+function transformNaturalReactivity(code, isTs) {
+    // If no '$(' or '$q(' or '$qr(' usage, return original code for safety/speed
+    if (!code.includes('$(') && !code.includes('$q(') && !code.includes('$qr('))
+        return code;
+    const sourceFile = ts.createSourceFile('temp.ts', code, ts.ScriptTarget.Latest, true);
+    const reactiveVars = new Set();
+    const quantumVars = new Set();
+    const registerVars = new Set();
+    // Pass 1: Identification
+    function findReactiveVars(node) {
+        if (ts.isVariableStatement(node)) {
+            node.declarationList.declarations.forEach(decl => {
+                if (decl.initializer && ts.isCallExpression(decl.initializer)) {
+                    const expr = decl.initializer.expression;
+                    if (ts.isIdentifier(expr)) {
+                        if (expr.text === '$') {
+                            if (ts.isIdentifier(decl.name))
+                                reactiveVars.add(decl.name.text);
+                        }
+                        else if (expr.text === '$q') {
+                            if (ts.isIdentifier(decl.name))
+                                quantumVars.add(decl.name.text);
+                        }
+                        else if (expr.text === '$qr') {
+                            if (ts.isIdentifier(decl.name))
+                                registerVars.add(decl.name.text);
+                        }
+                    }
+                }
+            });
+        }
+        ts.forEachChild(node, findReactiveVars);
+    }
+    findReactiveVars(sourceFile);
+    if (reactiveVars.size === 0 && quantumVars.size === 0 && registerVars.size === 0)
+        return code;
+    // Pass 2: Transformation
+    const transformerFactory = (context) => {
+        return (rootNode) => {
+            function visit(node) {
+                if (ts.isVariableStatement(node)) {
+                    const newDecls = [];
+                    let changed = false;
+                    node.declarationList.declarations.forEach(decl => {
+                        if (ts.isIdentifier(decl.name)) {
+                            const name = decl.name.text;
+                            if (reactiveVars.has(name) || quantumVars.has(name) || registerVars.has(name)) {
+                                changed = true;
+                                let hookName = 'muState';
+                                if (quantumVars.has(name))
+                                    hookName = 'muQubit';
+                                else if (registerVars.has(name))
+                                    hookName = 'muRegister';
+                                const init = decl.initializer;
+                                newDecls.push(ts.factory.updateVariableDeclaration(decl, decl.name, decl.exclamationToken, decl.type, ts.factory.createCallExpression(ts.factory.createIdentifier(hookName), undefined, init.arguments)));
+                            }
+                            else {
+                                newDecls.push(decl);
+                            }
+                        }
+                        else {
+                            newDecls.push(decl);
+                        }
+                    });
+                    if (changed) {
+                        return ts.factory.createVariableStatement(node.modifiers, ts.factory.createVariableDeclarationList(newDecls, ts.NodeFlags.Const));
+                    }
+                }
+                if (ts.isCallExpression(node)) {
+                    const expr = node.expression;
+                    if (ts.isIdentifier(expr)) {
+                        const name = expr.text;
+                        const isMacro = name === '$' || name === '$q' || name === '$qr';
+                        if (isMacro) {
+                            // If this call is the initializer of a variable declaration being handled, 
+                            // it will be transformed by the VariableStatement logic above.
+                            // However, we want to transform it here if it's used as a STANDALONE expression (e.g. assignment).
+                            const parent = node.parent;
+                            const isDeclarationInit = ts.isVariableDeclaration(parent) && parent.initializer === node;
+                            if (!isDeclarationInit) {
+                                let hookName = 'muState';
+                                if (name === '$q')
+                                    hookName = 'muQubit';
+                                else if (name === '$qr')
+                                    hookName = 'muRegister';
+                                // Transform $(x) -> muState(x).value
+                                return ts.factory.createPropertyAccessExpression(ts.factory.createCallExpression(ts.factory.createIdentifier(hookName), undefined, node.arguments), ts.factory.createIdentifier('value'));
+                            }
+                        }
+                    }
+                }
+                if (ts.isIdentifier(node)) {
+                    const name = node.text;
+                    if (reactiveVars.has(name) || quantumVars.has(name) || registerVars.has(name)) {
+                        const parent = node.parent;
+                        if (ts.isVariableDeclaration(parent) && parent.name === node)
+                            return node;
+                        if (ts.isPropertyAccessExpression(parent) && parent.name === node)
+                            return node;
+                        if (ts.isPropertyAccessExpression(parent) && parent.expression === node && parent.name.text === 'value')
+                            return node;
+                        if (ts.isPropertyAssignment(parent) && parent.name === node)
+                            return node;
+                        // EXEMPTION: Do not add .value if the identifier is a direct argument to a Mulan hook
+                        // These hooks (muGate, muMeasure, etc.) expect the signal wrapper.
+                        if (ts.isCallExpression(parent) && ts.isIdentifier(parent.expression)) {
+                            const hook = parent.expression.text;
+                            if (COMMON_HOOKS.includes(hook))
+                                return node;
+                        }
+                        return ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(name), ts.factory.createIdentifier('value'));
+                    }
+                }
+                return ts.visitEachChild(node, visit, context);
+            }
+            return ts.visitNode(rootNode, visit);
+        };
+    };
+    const result = ts.transform(sourceFile, [transformerFactory]);
+    const printer = ts.createPrinter();
+    return printer.printFile(result.transformed[0]);
+}

package/dist/compiler/sfc-parser.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMUJS = parseMUJS;
+/**
+ * Standardized State-Machine Parser for MulanJS
+ * Parses .mujs files safely, handling attributes, quotes, and nested content.
+ */
+function parseMUJS(source, filename) {
+    const descriptor = {
+        filename,
+        source,
+        template: null,
+        script: null,
+        scripts: [],
+        styles: [],
+        customBlocks: []
+    };
+    let cursor = 0;
+    const length = source.length;
+    while (cursor < length) {
+        // Look for start tag '<'
+        const start = source.indexOf('<', cursor);
+        if (start === -1)
+            break; // End of file
+        // Must be safe start (not in comment/string - simplified for top-level blocks)
+        // We assume SFC top-level blocks are valid HTML-like tags.
+        // Check if closing tag (ignore)
+        if (source[start + 1] === '/') {
+            cursor = start + 1;
+            continue;
+        }
+        // Parse Tag Name
+        let nameEnd = start + 1;
+        while (nameEnd < length && !/\s|>/.test(source[nameEnd])) {
+            nameEnd++;
+        }
+        const tagName = source.slice(start + 1, nameEnd);
+        // Parse Attributes
+        let attrStart = nameEnd;
+        const attrs = {};
+        let tagEnd = source.indexOf('>', attrStart);
+        if (tagEnd === -1)
+            break;
+        const attrString = source.slice(attrStart, tagEnd);
+        // Simple regex for attrs is safe *inside* the tag definition
+        const attrRegex = /([a-zA-Z0-9:-]+)(?:=["']([^"']*)["'])?/g;
+        let match;
+        while ((match = attrRegex.exec(attrString)) !== null) {
+            attrs[match[1]] = match[2] || 'true';
+        }
+        // Find Closing Tag
+        // We need to handle nested content.
+        // For <template>, we just look for </template>.
+        // For <script>, same.
+        // "Naive" approach: indexOf('</' + tagName) is actually standard for SFC parsers 
+        // because top-level blocks shouldn't contain their own closing tag as text 
+        // (except unless escaped, which we can handle if needed, but rarely an issue for top-level).
+        const contentStart = tagEnd + 1;
+        const closeTag = `</${tagName}>`;
+        const contentEnd = source.indexOf(closeTag, contentStart);
+        if (contentEnd === -1) {
+            // Unclosed block, invalid SFC.
+            console.warn(`[MulanJS Parser] Unclosed block: <${tagName}>`);
+            break;
+        }
+        const content = source.slice(contentStart, contentEnd);
+        const block = {
+            type: tagName,
+            content: content.trim(), // Trim content for cleanliness
+            attrs,
+            start: start,
+            end: contentEnd + closeTag.length
+        };
+        // Add to descriptor
+        if (tagName === 'template' || tagName === 'mu-template') {
+            descriptor.template = block;
+        }
+        else if (tagName === 'script') {
+            descriptor.scripts.push(block);
+            if (attrs.setup || !descriptor.script) {
+                descriptor.script = block;
+            }
+        }
+        else if (tagName === 'style') {
+            descriptor.styles.push(block);
+        }
+        else {
+            descriptor.customBlocks.push(block);
+        }
+        cursor = contentEnd + closeTag.length;
+    }
+    return descriptor;
+}

package/dist/compiler/style-compiler.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileStyle = compileStyle;
+function compileStyle(descriptor, filename) {
+    const styles = descriptor.styles;
+    if (!styles || styles.length === 0)
+        return { css: '', errors: [] };
+    let combinedCss = '';
+    const scopedId = 'data-v-' + hash(filename);
+    styles.forEach(style => {
+        let content = style.content;
+        if (style.attrs.scoped) {
+            // SCSS Compilation
+            if (style.attrs.lang === 'scss' || style.attrs.lang === 'sass') {
+                try {
+                    const sass = require('sass');
+                    const result = sass.compileString(content, {
+                        syntax: style.attrs.lang === 'sass' ? 'indented' : 'scss'
+                    });
+                    content = result.css;
+                }
+                catch (e) {
+                    return { css: '', errors: [`SCSS Compilation Error: ${e.message}`] };
+                }
+            }
+            // Rewrite selectors
+            // Very naive regex replacer: "selector {" -> "selector[data-v-id] {"
+            // This is fragile but works for a PoC.
+            content = content.replace(/([^\r\n,{}]+)(?=\{)/g, (match) => {
+                const selectors = match.split(',');
+                return selectors.map(s => {
+                    const selector = s.trim();
+                    if (selector.startsWith('@') || selector === 'from' || selector === 'to')
+                        return selector; // Skip keyframes/media
+                    return `${selector}[${scopedId}]`;
+                }).join(', ');
+            });
+        }
+        combinedCss += content + '\n';
+    });
+    return {
+        css: combinedCss,
+        scopedId,
+        errors: []
+    };
+}
+// Simple hash for ID generation
+function hash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash &= hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash).toString(36);
+}