@motifx/compiler 1.0.1 → 1.2.0-rc.0

package/dist/index.cjs

@@ -15,6 +15,7 @@ var htmlTags = require('html-tags');
 var svgTags = require('svg-tags');
 var generatorNs = require('@babel/generator');
 var path = require('node:path');
+var node_fs = require('node:fs');
 var ts = require('typescript');
 var pPath = require('path');
 
@@ -510,12 +511,6 @@ const makeHtmlAttr = (prop, name, value, path) => {
         return t__namespace.objectProperty(t__namespace.stringLiteral(name), value || t__namespace.booleanLiteral(true));
     }
     else if (t__namespace.isArrowFunctionExpression(value) && value !== null) {
-        if (t__namespace.isBlockStatement(value.body)) {
-            t__namespace.functionExpression(null, value.params, value.body);
-        }
-        else {
-            t__namespace.functionExpression(null, value.params, t__namespace.blockStatement([t__namespace.returnStatement(value.body)]));
-        }
         return t__namespace.objectProperty(t__namespace.stringLiteral(name), value);
     }
     else if (t__namespace.isFunctionExpression(value)) {
@@ -740,33 +735,9 @@ const mergeHtmlAttributes = (htmlAttrlist) => {
 };
 const makeHtmlEvents = (prop, name, value, path) => {
     if (!t__namespace.isStringLiteral(value) && !t__namespace.isBooleanLiteral(value) && value !== null) {
-        if (t__namespace.isArrowFunctionExpression(value)) {
-            var el;
-            if (t__namespace.isBlockStatement(value.body)) {
-                el = t__namespace.arrowFunctionExpression(value.params, value.body);
-            }
-            else {
-                el = t__namespace.arrowFunctionExpression(value.params, t__namespace.blockStatement([t__namespace.returnStatement(value.body)]));
-            }
-            var evName = name.toLowerCase().replace("on", '').replace('doubleclick', 'dblclick');
-            return t__namespace.callExpression(t__namespace.identifier("sender.motif.on"), [t__namespace.stringLiteral(evName), el]);
-        }
-        else if (t__namespace.isFunctionExpression(value)) {
-            var el;
-            if (t__namespace.isBlockStatement(value.body)) {
-                el = t__namespace.functionExpression(null, value.params, value.body);
-            }
-            else {
-                el = t__namespace.functionExpression(null, value.params, t__namespace.blockStatement([t__namespace.returnStatement(value.body)]));
-            }
+        if (t__namespace.isExpression(value)) {
             var evName = name.toLowerCase().replace("on", '').replace('doubleclick', 'dblclick');
-            return t__namespace.callExpression(t__namespace.identifier("sender.motif.on"), [t__namespace.stringLiteral(evName), el]);
-        }
-        else {
-            if (t__namespace.isExpression(value)) {
-                var evName = name.toLowerCase().replace("on", '').replace('doubleclick', 'dblclick');
-                return t__namespace.callExpression(t__namespace.identifier("sender.motif.on"), [t__namespace.stringLiteral(evName), value]);
-            }
+            return t__namespace.callExpression(t__namespace.identifier("sender.motif.on"), [t__namespace.stringLiteral(evName), value]);
         }
     }
     else {
@@ -823,7 +794,10 @@ const ParentIfStatement = (path, state) => {
     else ;
     return state;
 };
-const returnIfStatement = (value, enableDefaultreturn = true, defaultLiteral = t__namespace.booleanLiteral(false)) => {
+const returnIfStatement = (value, enableDefaultreturn = true, defaultLiteral = t__namespace.booleanLiteral(false), callFunctions = false) => {
+    if (callFunctions && t__namespace.isFunctionExpression(value)) {
+        return value;
+    }
     var ifStatement = findIfStatements(value);
     var mx = t__namespace.binaryExpression('===', t__namespace.unaryExpression('typeof', value), t__namespace.stringLiteral('function'));
     var rtrn;
@@ -837,13 +811,15 @@ const returnIfStatement = (value, enableDefaultreturn = true, defaultLiteral = t
         }
     }
     else if (t__namespace.isMemberExpression(value) || t__namespace.isIdentifier(value)) {
-        rtrn = t__namespace.returnStatement(value);
+        rtrn = t__namespace.returnStatement(callFunctions
+            ? t__namespace.conditionalExpression(t__namespace.binaryExpression('===', t__namespace.unaryExpression('typeof', value), t__namespace.stringLiteral('function')), t__namespace.callExpression(value, []), value)
+            : value);
         var rtrns = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([rtrn]));
         if (enableDefaultreturn) {
-            return t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns, t__namespace.returnStatement(defaultLiteral)]));
+            return cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns, t__namespace.returnStatement(defaultLiteral)])), [value]);
         }
         else {
-            return t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns]));
+            return cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns])), [value]);
         }
     }
     else if (t__namespace.isFunctionExpression(value)) {
@@ -862,20 +838,20 @@ const returnIfStatement = (value, enableDefaultreturn = true, defaultLiteral = t
         var le = t__namespace.logicalExpression('&&', ifStatementA, ifStatementB);
         rtrn = t__namespace.returnStatement(value);
         if (enableDefaultreturn) {
-            return t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([t__namespace.ifStatement(le, t__namespace.blockStatement([rtrn])), t__namespace.returnStatement(defaultLiteral)]));
+            return cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([t__namespace.ifStatement(le, t__namespace.blockStatement([rtrn])), t__namespace.returnStatement(defaultLiteral)])), [value.left, value.right]);
         }
         else {
-            return t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([t__namespace.ifStatement(le, t__namespace.blockStatement([rtrn]))]));
+            return cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([t__namespace.ifStatement(le, t__namespace.blockStatement([rtrn]))])), [value.left, value.right]);
         }
     }
     else if (t__namespace.isCallExpression(value)) {
         rtrn = t__namespace.returnStatement(t__namespace.conditionalExpression(mx, t__namespace.callExpression(value, []), value));
         var rtrns = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([rtrn]));
         if (enableDefaultreturn) {
-            return t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns, t__namespace.returnStatement(defaultLiteral)]));
+            return cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns, t__namespace.returnStatement(defaultLiteral)])), [value]);
         }
         else {
-            return t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns]));
+            return cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns])), [value]);
         }
     }
     else {
@@ -945,6 +921,95 @@ const findIfStatements = (value) => {
     }
     return ifStatement;
 };
+const isEffectNode = (node) => t__namespace.isCallExpression(node) || t__namespace.isOptionalCallExpression(node) || t__namespace.isNewExpression(node) ||
+    t__namespace.isTaggedTemplateExpression(node) || t__namespace.isUpdateExpression(node) || t__namespace.isAssignmentExpression(node) ||
+    t__namespace.isAwaitExpression(node) || t__namespace.isYieldExpression(node);
+const hasEffect = (node) => {
+    if (!node || t__namespace.isFunction(node) || t__namespace.isClass(node))
+        return false;
+    if (isEffectNode(node))
+        return true;
+    for (const key of t__namespace.VISITOR_KEYS[node.type] ?? []) {
+        const child = node[key];
+        if (Array.isArray(child) ? child.some(c => hasEffect(c)) : hasEffect(child))
+            return true;
+    }
+    return false;
+};
+const guardCallLinks = (root, found) => {
+    if (!t__namespace.isExpression(root) || t__namespace.isFunction(root))
+        return;
+    if (!t__namespace.isIdentifier(root) && !t__namespace.isMemberExpression(root) && !t__namespace.isThisExpression(root) && !t__namespace.isLiteral(root) && hasEffect(root)) {
+        found.add(root);
+    }
+    if (t__namespace.isMemberExpression(root))
+        guardCallLinks(root.object, found);
+    else if (t__namespace.isCallExpression(root) && t__namespace.isExpression(root.callee))
+        guardCallLinks(root.callee, found);
+};
+const collectNames = (node, names) => {
+    if (!node)
+        return;
+    if (t__namespace.isIdentifier(node))
+        names.add(node.name);
+    for (const key of t__namespace.VISITOR_KEYS[node.type] ?? []) {
+        const child = node[key];
+        if (Array.isArray(child))
+            child.forEach(c => collectNames(c, names));
+        else
+            collectNames(child, names);
+    }
+};
+const cacheGuardCalls = (fn, roots) => {
+    if (!t__namespace.isBlockStatement(fn.body))
+        return fn;
+    const links = new Set();
+    roots.forEach(r => guardCallLinks(r, links));
+    if (links.size === 0)
+        return fn;
+    const used = new Set();
+    collectNames(fn, used);
+    const assigned = new Map();
+    let counter = 0;
+    const nextName = () => {
+        let name;
+        do {
+            name = `__r${++counter}`;
+        } while (used.has(name));
+        return name;
+    };
+    const rewrite = (node) => {
+        if (!node || typeof node !== 'object' || !node.type)
+            return node;
+        if (links.has(node)) {
+            const known = assigned.get(node);
+            if (known)
+                return t__namespace.identifier(known);
+            const name = nextName();
+            assigned.set(node, name);
+            return t__namespace.assignmentExpression('=', t__namespace.identifier(name), rewriteChildren(node));
+        }
+        if (t__namespace.isFunction(node) || t__namespace.isClass(node))
+            return node;
+        return rewriteChildren(node);
+    };
+    const rewriteChildren = (node) => {
+        const copy = t__namespace.cloneNode(node, false);
+        for (const key of t__namespace.VISITOR_KEYS[node.type] ?? []) {
+            const child = node[key];
+            copy[key] = Array.isArray(child) ? child.map(rewrite) : rewrite(child);
+        }
+        return copy;
+    };
+    const body = rewriteChildren(fn.body);
+    if (assigned.size === 0)
+        return fn;
+    const declaration = t__namespace.variableDeclaration('let', [...assigned.values()].map(name => t__namespace.variableDeclarator(t__namespace.identifier(name))));
+    body.body.unshift(declaration);
+    const result = t__namespace.cloneNode(fn, false);
+    result.body = body;
+    return result;
+};
 const makeDirectives = (prop, name, value, path, state) => {
     var result = null;
     if (value != null) {
@@ -983,7 +1048,7 @@ const makeDirectives = (prop, name, value, path, state) => {
                     }
                     else {
                         if (t__namespace.isExpression(value)) {
-                            result = t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.identifier(callerName), [returnIfStatement(value, false)]));
+                            result = t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.identifier(callerName), [returnIfStatement(value, false, t__namespace.booleanLiteral(false), true)]));
                         }
                     }
                 }
@@ -1065,7 +1130,7 @@ const makePreDirectives = (prop, name, value, path) => {
                 fail('MJX012', `Directive "${name}" does not accept an object literal.`, prop);
             }
             else if (t__namespace.isExpression(value)) {
-                result = t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.identifier(callerName), [returnIfStatement(value, true, t__namespace.booleanLiteral(true))]));
+                result = t__namespace.expressionStatement(t__namespace.callExpression(t__namespace.identifier(callerName), [returnIfStatement(value, true, t__namespace.booleanLiteral(true), true)]));
             }
         }
         else {
@@ -1606,7 +1671,7 @@ const getProps = (props, path, state) => {
             refEntries.push({ prop, lowered: t__namespace.arrowFunctionExpression([t__namespace.identifier('sender')], t__namespace.blockStatement(body)) });
         }
         else if (t__namespace.isFunctionExpression(value) || t__namespace.isArrowFunctionExpression(value)) {
-            refEntries.push({ prop, lowered: t__namespace.arrowFunctionExpression(value.params, value.body) });
+            refEntries.push({ prop, lowered: t__namespace.arrowFunctionExpression(value.params, value.body, value.async) });
         }
         else if (t__namespace.isExpression(value)) {
             var cx = t__namespace.expressionStatement(value);
@@ -2239,7 +2304,7 @@ const mkText = (exp) => {
             var mx = t__namespace.binaryExpression('===', t__namespace.unaryExpression('typeof', exp), t__namespace.stringLiteral('function'));
             var rtrn = t__namespace.returnStatement(t__namespace.conditionalExpression(mx, t__namespace.callExpression(exp, []), t__namespace.arrowFunctionExpression([], exp)));
             var rtrns = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([rtrn]));
-            var kx = t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns]));
+            var kx = cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns])), [exp]);
             a1 = t__namespace.callExpression(id('sender.bindings.add'), [t__namespace.stringLiteral("textContent"), kx]);
         }
     }
@@ -2305,7 +2370,7 @@ const mkText = (exp) => {
             // var a1 = t.callExpression(id('sender.bind.logic'), [kx, exp.right]);
             var rtrns = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([t__namespace.returnStatement(exp.left)]));
             var tryStatement = t__namespace.tryStatement(t__namespace.blockStatement([rtrns]), t__namespace.catchClause(null, t__namespace.blockStatement([t__namespace.returnStatement(t__namespace.nullLiteral())])), null);
-            var kx = t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([tryStatement]));
+            var kx = cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([tryStatement])), [exp.left]);
             if (!t__namespace.isFunctionDeclaration(exp.right) && !t__namespace.isArrowFunctionExpression(exp.right)) {
                 t__namespace.ifStatement(t__namespace.identifier('__v'), t__namespace.blockStatement([t__namespace.returnStatement(exp.right)]), t__namespace.blockStatement([t__namespace.returnStatement(t__namespace.callExpression(t__namespace.identifier(motifComponent()), [t__namespace.objectExpression([])]))]));
                 exp.right = t__namespace.arrowFunctionExpression([t__namespace.identifier("__v")], t__namespace.blockStatement([t__namespace.returnStatement(exp.right)]));
@@ -2325,7 +2390,7 @@ const mkText = (exp) => {
         var mx = t__namespace.binaryExpression('===', t__namespace.unaryExpression('typeof', exp), t__namespace.stringLiteral('function'));
         var rtrn = t__namespace.returnStatement(t__namespace.conditionalExpression(mx, t__namespace.callExpression(exp, []), t__namespace.arrowFunctionExpression([], exp)));
         var rtrns = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([rtrn]));
-        var kx = t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns]));
+        var kx = cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns])), [exp]);
         a1 = t__namespace.callExpression(id('sender.bindings.add'), [t__namespace.stringLiteral("textContent"), kx]);
     }
     else {
@@ -2333,7 +2398,7 @@ const mkText = (exp) => {
         var mx = t__namespace.binaryExpression('===', t__namespace.unaryExpression('typeof', exp), t__namespace.stringLiteral('function'));
         var rtrn = t__namespace.returnStatement(t__namespace.conditionalExpression(mx, t__namespace.callExpression(exp, []), t__namespace.arrowFunctionExpression([], exp)));
         var rtrns = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([rtrn]));
-        var kx = t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns]));
+        var kx = cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([rtrns])), [exp]);
         a1 = t__namespace.callExpression(id('sender.bindings.add'), [t__namespace.stringLiteral("textContent"), kx]);
     }
     var arrayBody = t__namespace.arrowFunctionExpression([id('sender')], t__namespace.blockStatement([t__namespace.expressionStatement(a1)]));
@@ -2499,7 +2564,7 @@ function ParseComponent(path, state) {
                     // var rtrn = t.returnStatement(t.conditionalExpression(mx, t.callExpression(cx.left, []), t.arrowFunctionExpression([], cx.left)));
                     var rtrns = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([t__namespace.returnStatement(cx.left)]));
                     var tryStatement = t__namespace.tryStatement(t__namespace.blockStatement([rtrns]), t__namespace.catchClause(null, t__namespace.blockStatement([t__namespace.returnStatement(t__namespace.nullLiteral())])), null);
-                    var kx = t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([tryStatement]));
+                    var kx = cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([tryStatement])), [cx.left]);
                     if (!t__namespace.isFunctionDeclaration(cx.right) && !t__namespace.isArrowFunctionExpression(cx.right)) {
                         t__namespace.ifStatement(t__namespace.identifier('__v'), t__namespace.blockStatement([t__namespace.returnStatement(cx.right)]), t__namespace.blockStatement([t__namespace.returnStatement(t__namespace.callExpression(t__namespace.identifier(motifComponent()), [t__namespace.objectExpression([])]))]));
                         cx.right = t__namespace.arrowFunctionExpression([t__namespace.identifier("__v")], t__namespace.blockStatement([t__namespace.returnStatement(cx.right)]));
@@ -2644,7 +2709,7 @@ function ParseFrament(path, state) {
                     else {
                         var rtrnsPlain = t__namespace.ifStatement(ifStatement, t__namespace.blockStatement([t__namespace.returnStatement(exp.left)]));
                         var tryStatement = t__namespace.tryStatement(t__namespace.blockStatement([rtrnsPlain]), t__namespace.catchClause(null, t__namespace.blockStatement([t__namespace.returnStatement(t__namespace.nullLiteral())])), null);
-                        condFn = t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([tryStatement]));
+                        condFn = cacheGuardCalls(t__namespace.arrowFunctionExpression([], t__namespace.blockStatement([tryStatement])), [exp.left]);
                     }
                     if (!t__namespace.isFunctionDeclaration(exp.right) && !t__namespace.isArrowFunctionExpression(exp.right)) {
                         exp.right = t__namespace.arrowFunctionExpression([t__namespace.identifier("val")], t__namespace.blockStatement([t__namespace.returnStatement(exp.right)]));
@@ -3090,12 +3155,9 @@ class Compiler {
                 },
                 function devOnlyStrip() {
                     let isDev = true;
-                    try {
-                        const flag = (0, eval)('typeof __MOTIF_DEV__ !== "undefined" ? __MOTIF_DEV__ : undefined');
-                        if (typeof flag === 'boolean')
-                            isDev = flag;
-                    }
-                    catch { /* ignore */ }
+                    const flag = globalThis.__MOTIF_DEV__;
+                    if (typeof flag === 'boolean')
+                        isDev = flag;
                     if (typeof process !== 'undefined' && process?.env?.MOTIF_DEV === 'false')
                         isDev = false;
                     const consumed = new WeakSet();
@@ -3156,11 +3218,492 @@ class Compiler {
     }
 }
 
+const SUPER_METHODS = ['build', 'setState', 'reState', 'setText', 'style', 'dispose', 'disposeAsync', 'using', 'doWork', 'getService', '$', 'useModel'];
+const SUPER_ACCESSORS = ['context', 'siblings', 'serviceProvider', 'isWait'];
+const CORE_COMPONENT_CLASSES = ['Component', 'ComponentBase', 'ContentBlock', 'ContentBody', 'FragmentNode', 'Frame', 'RouterLink', 'RouterView', 'Transport', 'TransportTo', 'Virtualization'];
+const coreComponents = new Set(CORE_COMPONENT_CLASSES);
+const superNames = new Set([...SUPER_METHODS, ...SUPER_ACCESSORS]);
+const quickMember = new RegExp(`(?:^|[\\s;{}])(?:async\\s+|get\\s+|set\\s+|override\\s+|public\\s+|protected\\s+)*(?:${[...superNames].map(n => n.replace('$', '\\$')).join('|')})\\s*\\(`, 'm');
+function mayHaveSuperOverrides(code) {
+    return /\bextends\b/.test(code) && quickMember.test(code);
+}
+function isCoreSource(source) {
+    return source === '@motifx/core' || source.startsWith('@motifx/core/');
+}
+function isCoreComponent(name) {
+    return coreComponents.has(name);
+}
+function parseModule(code, filename) {
+    const isTs = /\.[mc]?tsx?$/.test(filename);
+    const isTsx = /\.tsx$/.test(filename);
+    const plugins = isTs ? ['typescript', 'decorators-legacy', 'classProperties'] : ['jsx', 'decorators-legacy', 'classProperties'];
+    if (isTsx)
+        plugins.push('jsx');
+    try {
+        const ast = babel__namespace.parseSync(code, {
+            filename,
+            babelrc: false,
+            configFile: false,
+            browserslistConfigFile: false,
+            sourceType: 'unambiguous',
+            parserOpts: { plugins, errorRecovery: true },
+        });
+        return ast ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function isSuperMember(node, name) {
+    if (!node || !(t__namespace.isMemberExpression(node) || t__namespace.isOptionalMemberExpression(node)) || !t__namespace.isSuper(node.object))
+        return false;
+    if (!node.computed && t__namespace.isIdentifier(node.property))
+        return node.property.name === name;
+    return t__namespace.isStringLiteral(node.property) && node.property.value === name;
+}
+function directUse(node, name, use) {
+    if (use === 'call' && (t__namespace.isCallExpression(node) || t__namespace.isOptionalCallExpression(node))) {
+        const callee = node.callee;
+        if (isSuperMember(callee, name))
+            return true;
+        if ((t__namespace.isMemberExpression(callee) || t__namespace.isOptionalMemberExpression(callee)) && isSuperMember(callee.object, name)
+            && t__namespace.isIdentifier(callee.property) && (callee.property.name === 'call' || callee.property.name === 'apply'))
+            return true;
+    }
+    if (use === 'get' && isSuperMember(node, name))
+        return true;
+    if (use === 'set' && t__namespace.isAssignmentExpression(node) && isSuperMember(node.left, name))
+        return true;
+    return false;
+}
+function definitely(node, name, use) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (t__namespace.isFunction(node) || t__namespace.isClass(node))
+        return false;
+    if (directUse(node, name, use))
+        return true;
+    if (use === 'get' && t__namespace.isAssignmentExpression(node) && isSuperMember(node.left, name))
+        return definitely(node.right, name, use);
+    if (t__namespace.isLogicalExpression(node))
+        return definitely(node.left, name, use);
+    if (t__namespace.isConditionalExpression(node))
+        return definitely(node.test, name, use) || (definitely(node.consequent, name, use) && definitely(node.alternate, name, use));
+    if (t__namespace.isOptionalCallExpression(node) || t__namespace.isOptionalMemberExpression(node)) {
+        const head = t__namespace.isOptionalCallExpression(node) ? node.callee : node.object;
+        return definitely(head, name, use);
+    }
+    for (const key of t__namespace.VISITOR_KEYS[node.type] ?? []) {
+        const child = node[key];
+        if (Array.isArray(child) ? child.some(c => definitely(c, name, use)) : definitely(child, name, use))
+            return true;
+    }
+    return false;
+}
+function mentions(node, name, use) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (directUse(node, name, use))
+        return true;
+    if (t__namespace.isClass(node))
+        return false;
+    for (const key of t__namespace.VISITOR_KEYS[node.type] ?? []) {
+        const child = node[key];
+        if (Array.isArray(child) ? child.some(c => mentions(c, name, use)) : mentions(child, name, use))
+            return true;
+    }
+    return false;
+}
+const join = (a, b) => a === null ? b : b === null ? a : a && b;
+const GUARDS = {
+    build: ['isBuilt', 'isDisposed', 'isWait'],
+    dispose: ['isDisposed'],
+    disposeAsync: ['isDisposed'],
+};
+function isGuardTest(test, member) {
+    const allowed = GUARDS[member];
+    if (!allowed)
+        return false;
+    if (t__namespace.isLogicalExpression(test) && test.operator === '||')
+        return isGuardTest(test.left, member) && isGuardTest(test.right, member);
+    return t__namespace.isMemberExpression(test) && t__namespace.isThisExpression(test.object) && !test.computed && t__namespace.isIdentifier(test.property) && allowed.includes(test.property.name);
+}
+function isBareReturn(node) {
+    if (t__namespace.isReturnStatement(node))
+        return true;
+    return t__namespace.isBlockStatement(node) && node.body.length === 1 && t__namespace.isReturnStatement(node.body[0]);
+}
+function flow(node, called, name, use, member) {
+    const plain = (c) => ({ normal: c, returns: true, breaks: null, continues: null });
+    if (!node)
+        return plain(called);
+    const d = (e) => called || definitely(e, name, use);
+    if (t__namespace.isBlockStatement(node) || t__namespace.isProgram(node))
+        return block(node.body, called, name, use, member);
+    if (t__namespace.isExpressionStatement(node))
+        return plain(d(node.expression));
+    if (t__namespace.isVariableDeclaration(node))
+        return plain(called || node.declarations.some(x => definitely(x.init, name, use)));
+    if (t__namespace.isReturnStatement(node))
+        return { normal: null, returns: d(node.argument), breaks: null, continues: null };
+    if (t__namespace.isThrowStatement(node))
+        return { normal: null, returns: true, breaks: null, continues: null };
+    if (t__namespace.isBreakStatement(node))
+        return { normal: null, returns: true, breaks: called, continues: null };
+    if (t__namespace.isContinueStatement(node))
+        return { normal: null, returns: true, breaks: null, continues: called };
+    if (t__namespace.isIfStatement(node)) {
+        const tc = d(node.test);
+        if (!tc && isGuardTest(node.test, member) && isBareReturn(node.consequent)) {
+            const alt = node.alternate ? flow(node.alternate, tc, name, use, member) : plain(tc);
+            return { normal: alt.normal, returns: alt.returns, breaks: alt.breaks, continues: alt.continues };
+        }
+        const cons = flow(node.consequent, tc, name, use, member);
+        const alt = node.alternate ? flow(node.alternate, tc, name, use, member) : plain(tc);
+        return { normal: join(cons.normal, alt.normal), returns: cons.returns && alt.returns, breaks: join(cons.breaks, alt.breaks), continues: join(cons.continues, alt.continues) };
+    }
+    if (t__namespace.isWhileStatement(node) || t__namespace.isForStatement(node) || t__namespace.isForInStatement(node) || t__namespace.isForOfStatement(node)) {
+        let tc = called;
+        if (t__namespace.isForStatement(node))
+            tc = called || definitely(node.init, name, use) || definitely(node.test, name, use);
+        else if (t__namespace.isWhileStatement(node))
+            tc = d(node.test);
+        else
+            tc = d(node.right);
+        const body = flow(node.body, tc, name, use, member);
+        return { normal: join(tc, body.breaks), returns: body.returns, breaks: null, continues: null };
+    }
+    if (t__namespace.isDoWhileStatement(node)) {
+        const body = flow(node.body, called, name, use, member);
+        const afterBody = join(body.normal, body.continues);
+        const afterTest = afterBody === null ? null : afterBody || definitely(node.test, name, use);
+        return { normal: join(afterTest, body.breaks), returns: body.returns, breaks: null, continues: null };
+    }
+    if (t__namespace.isSwitchStatement(node)) {
+        const dc = d(node.discriminant);
+        let fall = null;
+        let returns = true;
+        let breaks = null;
+        let continues = null;
+        let hasDefault = false;
+        for (const c of node.cases) {
+            if (!c.test)
+                hasDefault = true;
+            const entry = join(fall, dc || definitely(c.test, name, use));
+            const out = entry === null ? null : block(c.consequent, entry, name, use, member);
+            if (out) {
+                returns = returns && out.returns;
+                breaks = join(breaks, out.breaks);
+                continues = join(continues, out.continues);
+                fall = out.normal;
+            }
+            else {
+                fall = null;
+            }
+        }
+        let normal = join(fall, breaks);
+        if (!hasDefault)
+            normal = join(normal, dc);
+        return { normal, returns, breaks: null, continues };
+    }
+    if (t__namespace.isTryStatement(node)) {
+        const tryOut = flow(node.block, called, name, use, member);
+        const catchOut = node.handler ? flow(node.handler.body, called, name, use, member) : null;
+        let normal = catchOut ? join(tryOut.normal, catchOut.normal) : tryOut.normal;
+        let returns = tryOut.returns && (catchOut ? catchOut.returns : true);
+        let breaks = catchOut ? join(tryOut.breaks, catchOut.breaks) : tryOut.breaks;
+        let continues = catchOut ? join(tryOut.continues, catchOut.continues) : tryOut.continues;
+        if (node.finalizer) {
+            const fin = flow(node.finalizer, false, name, use, member);
+            if (fin.normal === true) {
+                normal = normal === null ? null : true;
+                returns = true;
+                breaks = breaks === null ? null : true;
+                continues = continues === null ? null : true;
+            }
+            else if (fin.normal === null) {
+                return { normal: null, returns: returns && fin.returns, breaks: fin.breaks, continues: fin.continues };
+            }
+            returns = returns && fin.returns;
+        }
+        return { normal, returns, breaks, continues };
+    }
+    if (t__namespace.isLabeledStatement(node)) {
+        const body = flow(node.body, called, name, use, member);
+        return { normal: join(body.normal, body.breaks), returns: body.returns, breaks: null, continues: body.continues };
+    }
+    if (t__namespace.isFunctionDeclaration(node) || t__namespace.isClassDeclaration(node))
+        return plain(called);
+    let c = called;
+    for (const key of t__namespace.VISITOR_KEYS[node.type] ?? []) {
+        const child = node[key];
+        if (Array.isArray(child) ? child.some(x => definitely(x, name, use)) : definitely(child, name, use)) {
+            c = true;
+            break;
+        }
+    }
+    return plain(c);
+}
+function block(body, called, name, use, member) {
+    let state = called;
+    let returns = true;
+    let breaks = null;
+    let continues = null;
+    for (const s of body) {
+        if (state === null)
+            break;
+        const out = flow(s, state, name, use, member);
+        returns = returns && out.returns;
+        breaks = join(breaks, out.breaks);
+        continues = join(continues, out.continues);
+        state = out.normal;
+    }
+    return { normal: state, returns, breaks, continues };
+}
+function checkMemberBody(body, member, accessor) {
+    const use = accessor === 'method' ? 'call' : accessor;
+    if (!mentions(body, member, use))
+        return 'never';
+    const out = flow(body, false, member, use, member);
+    return out.normal !== false && out.returns ? 'ok' : 'path';
+}
+function memberName(m) {
+    const key = m.key;
+    if (m.computed)
+        return t__namespace.isStringLiteral(key) ? key.value : null;
+    if (t__namespace.isIdentifier(key))
+        return key.name;
+    if (t__namespace.isStringLiteral(key))
+        return key.value;
+    return null;
+}
+function analyzeModule(ast) {
+    const imports = new Map();
+    const classes = new Map();
+    const exportsMap = new Map();
+    const starSources = [];
+    const findings = [];
+    const classNodes = [];
+    const noteClass = (node, name) => {
+        if (name)
+            classes.set(name, node);
+        classNodes.push({ node, name: name ?? 'An anonymous class' });
+    };
+    const walk = (node, parent) => {
+        if (!node || typeof node !== 'object' || !node.type)
+            return;
+        if (t__namespace.isImportDeclaration(node)) {
+            for (const s of node.specifiers) {
+                if (t__namespace.isImportSpecifier(s))
+                    imports.set(s.local.name, { source: node.source.value, name: t__namespace.isIdentifier(s.imported) ? s.imported.name : s.imported.value });
+                else if (t__namespace.isImportDefaultSpecifier(s))
+                    imports.set(s.local.name, { source: node.source.value, name: 'default' });
+                else if (t__namespace.isImportNamespaceSpecifier(s))
+                    imports.set(s.local.name, { source: node.source.value, name: '*' });
+            }
+        }
+        else if (t__namespace.isExportNamedDeclaration(node)) {
+            if (node.source) {
+                for (const s of node.specifiers) {
+                    if (t__namespace.isExportSpecifier(s)) {
+                        const exported = t__namespace.isIdentifier(s.exported) ? s.exported.name : s.exported.value;
+                        exportsMap.set(exported, { from: node.source.value, imported: s.local.name });
+                    }
+                }
+            }
+            else {
+                for (const s of node.specifiers) {
+                    if (t__namespace.isExportSpecifier(s)) {
+                        const exported = t__namespace.isIdentifier(s.exported) ? s.exported.name : s.exported.value;
+                        exportsMap.set(exported, { local: s.local.name });
+                    }
+                }
+                const decl = node.declaration;
+                if (t__namespace.isClassDeclaration(decl) && decl.id)
+                    exportsMap.set(decl.id.name, { local: decl.id.name });
+                if (t__namespace.isVariableDeclaration(decl)) {
+                    for (const v of decl.declarations)
+                        if (t__namespace.isIdentifier(v.id))
+                            exportsMap.set(v.id.name, { local: v.id.name });
+                }
+            }
+        }
+        else if (t__namespace.isExportDefaultDeclaration(node)) {
+            const decl = node.declaration;
+            if (t__namespace.isClassDeclaration(decl)) {
+                const local = decl.id?.name ?? '*default*';
+                if (!decl.id)
+                    classes.set(local, decl);
+                exportsMap.set('default', { local });
+            }
+            else if (t__namespace.isIdentifier(decl)) {
+                exportsMap.set('default', { local: decl.name });
+            }
+        }
+        else if (t__namespace.isExportAllDeclaration(node)) {
+            starSources.push(node.source.value);
+        }
+        if (t__namespace.isClassDeclaration(node)) {
+            noteClass(node, node.id?.name ?? (t__namespace.isExportDefaultDeclaration(parent) ? '*default*' : null));
+        }
+        else if (t__namespace.isClassExpression(node)) {
+            const name = node.id?.name ?? (t__namespace.isVariableDeclarator(parent) && t__namespace.isIdentifier(parent.id) ? parent.id.name : null);
+            noteClass(node, name);
+        }
+        for (const key of t__namespace.VISITOR_KEYS[node.type] ?? []) {
+            const child = node[key];
+            if (Array.isArray(child))
+                child.forEach(c => walk(c, node));
+            else
+                walk(child, node);
+        }
+    };
+    walk(ast.program, null);
+    const baseOf = (cls, seen) => {
+        if (seen.has(cls))
+            return { kind: 'unknown' };
+        seen.add(cls);
+        const sup = cls.superClass;
+        if (t__namespace.isIdentifier(sup)) {
+            const imp = imports.get(sup.name);
+            if (imp && imp.name !== '*')
+                return { kind: 'import', source: imp.source, name: imp.name };
+            const local = classes.get(sup.name);
+            if (local)
+                return baseOf(local, seen);
+            return { kind: 'unknown' };
+        }
+        if (t__namespace.isMemberExpression(sup) && t__namespace.isIdentifier(sup.object) && !sup.computed && t__namespace.isIdentifier(sup.property)) {
+            const imp = imports.get(sup.object.name);
+            if (imp && imp.name === '*')
+                return { kind: 'import', source: imp.source, name: sup.property.name };
+        }
+        return { kind: 'unknown' };
+    };
+    for (const { node, name } of classNodes) {
+        if (!node.superClass)
+            continue;
+        let base;
+        for (const m of node.body.body) {
+            if (!(t__namespace.isClassMethod(m) || t__namespace.isClassPrivateMethod(m)) || m.static || t__namespace.isClassPrivateMethod(m))
+                continue;
+            if (m.kind === 'constructor')
+                continue;
+            const member = memberName(m);
+            if (!member || !superNames.has(member))
+                continue;
+            const accessor = m.kind === 'get' ? 'get' : m.kind === 'set' ? 'set' : 'method';
+            if (accessor === 'method' && !SUPER_METHODS.includes(member))
+                continue;
+            if (accessor !== 'method' && !SUPER_ACCESSORS.includes(member))
+                continue;
+            const result = checkMemberBody(m.body, member, accessor);
+            if (result === 'ok')
+                continue;
+            base ??= baseOf(node, new Set());
+            findings.push({
+                className: name === '*default*' ? 'The default-exported class' : name,
+                member,
+                accessor,
+                kind: result,
+                line: m.loc?.start.line ?? 0,
+                column: m.loc?.start.column ?? 0,
+                classLine: node.loc?.start.line ?? 0,
+                base,
+            });
+        }
+    }
+    return {
+        findings,
+        classBase(exportedOrLocal) {
+            const cls = classes.get(exportedOrLocal);
+            return cls ? baseOf(cls, new Set()) : null;
+        },
+        exportOf(name) {
+            return exportsMap.get(name) ?? null;
+        },
+        starSources,
+    };
+}
+function superCallMessage(f) {
+    const target = f.accessor === 'get' ? `read super.${f.member}` : f.accessor === 'set' ? `assign super.${f.member}` : `call super.${f.member}(…)`;
+    return f.kind === 'never'
+        ? `${f.className}.${f.member} overrides a ComponentBase member and does not ${target}; MotifJS relies on it. Rename the member, or ${target} on every path.`
+        : `${f.className}.${f.member} can finish without reaching super.${f.member} (a return, a branch, a loop or a catch skips it); MotifJS relies on it. ${target[0].toUpperCase() + target.slice(1)} on every path.`;
+}
+function createComponentResolver(resolve, read) {
+    const cache = new Map();
+    const shapes = new Map();
+    const shapeOf = (file) => {
+        let p = shapes.get(file);
+        if (!p) {
+            p = (async () => {
+                const code = await read(file);
+                if (code == null || code.length > 2_000_000)
+                    return null;
+                const ast = parseModule(code, file);
+                return ast ? analyzeModule(ast) : null;
+            })();
+            shapes.set(file, p);
+        }
+        return p;
+    };
+    const isComponentExport = (file, name, depth) => {
+        const key = `${file}#${name}`;
+        let p = cache.get(key);
+        if (!p) {
+            cache.set(key, Promise.resolve(false));
+            p = (async () => {
+                if (depth > 12)
+                    return false;
+                const shape = await shapeOf(file);
+                if (!shape)
+                    return false;
+                const exp = shape.exportOf(name);
+                if (exp?.from)
+                    return isComponentBase({ kind: 'import', source: exp.from, name: exp.imported ?? name }, file, depth + 1);
+                const local = exp?.local ?? (name === 'default' ? '*default*' : null);
+                if (local) {
+                    const base = shape.classBase(local);
+                    if (base)
+                        return isComponentBase(base, file, depth + 1);
+                    return false;
+                }
+                for (const star of shape.starSources) {
+                    if (await isComponentBase({ kind: 'import', source: star, name }, file, depth + 1))
+                        return true;
+                }
+                return false;
+            })();
+            cache.set(key, p);
+        }
+        return p;
+    };
+    const isComponentBase = async (base, importer, depth = 0) => {
+        if (base.kind !== 'import')
+            return false;
+        if (isCoreSource(base.source))
+            return isCoreComponent(base.name);
+        let file = null;
+        try {
+            file = await resolve(base.source, importer);
+        }
+        catch {
+            file = null;
+        }
+        if (!file)
+            return false;
+        return isComponentExport(file, base.name, depth);
+    };
+    return isComponentBase;
+}
+
 const fileRegex = /\.(jsx|tsx|aio|mjsx|mtsx)$/;
 const decoratorFileRegex = /\.(ts|mts|cts|js|mjs|cjs)$/;
 const declarationFileRegex = /\.d\.[mc]?ts$/;
 const decoratorSyntaxRegex = /(?:^|[\s(,;{}])@[A-Za-z_$]/;
 const assetQueryRegex = /(?:^|&)(?:raw|url|worker|sharedworker|inline)(?:[&=]|$)/;
+const analyzableFileRegex = /\.(jsx|tsx|mjsx|mtsx|ts|mts|cts|js|mjs|cjs)$/;
 function sourceFile(id) {
     if (id.charCodeAt(0) === 0)
         return null;
@@ -3181,6 +3724,41 @@ function shouldLowerDecorators(id, src) {
         return false;
     return decoratorSyntaxRegex.test(src);
 }
+function shouldCheckSuperCalls(id, src) {
+    const file = sourceFile(id);
+    if (file === null || !analyzableFileRegex.test(file) || declarationFileRegex.test(file))
+        return false;
+    if (file.replace(/\\/g, '/').includes('/node_modules/'))
+        return false;
+    return mayHaveSuperOverrides(src);
+}
+function lineFrame(src, line, column) {
+    const lines = src.split(/\r?\n/);
+    if (line < 1 || line > lines.length)
+        return undefined;
+    const from = Math.max(1, line - 1);
+    const to = Math.min(lines.length, line + 1);
+    const width = String(to).length;
+    const out = [];
+    for (let i = from; i <= to; i++) {
+        out.push(`${i === line ? '>' : ' '} ${String(i).padStart(width)} | ${lines[i - 1]}`);
+        if (i === line)
+            out.push(`  ${' '.repeat(width)} | ${' '.repeat(column)}^`);
+    }
+    return out.join('\n');
+}
+async function checkSuperCalls(src, file, isComponentBase) {
+    const ast = parseModule(src, file);
+    if (!ast)
+        return [];
+    const out = [];
+    for (const f of analyzeModule(ast).findings) {
+        if (!(await isComponentBase(f.base, file)))
+            continue;
+        out.push({ code: 'MJX015', message: superCallMessage(f), file, line: f.line, frame: lineFrame(src, f.line, f.column) });
+    }
+    return out;
+}
 function legacyDecoratorsChecker() {
     const byConfig = new Map();
     return (file) => {
@@ -3208,10 +3786,45 @@ function explainMatches(opt, id) {
 function vitePlugin(options = {}) {
     const showDiagnostics = options.diagnostics !== false;
     const usesLegacyDecorators = legacyDecoratorsChecker();
+    let context = null;
+    const makeResolver = () => createComponentResolver(async (source, importer) => {
+        if (!context?.resolve)
+            return null;
+        const r = await context.resolve(source, importer, { skipSelf: true });
+        if (!r || r.external)
+            return null;
+        return sourceFile(r.id);
+    }, async (file) => {
+        try {
+            return await node_fs.promises.readFile(file, 'utf8');
+        }
+        catch {
+            return null;
+        }
+    });
+    let isComponentBase = makeResolver();
+    const pending = new Set();
     return {
         name: 'transform-file-motif-jsx',
         enforce: 'pre',
+        watchChange() {
+            isComponentBase = makeResolver();
+        },
+        handleHotUpdate() {
+            isComponentBase = makeResolver();
+        },
+        async buildEnd() {
+            await Promise.all([...pending]);
+        },
         transform(src, id) {
+            if (showDiagnostics && shouldCheckSuperCalls(id, src)) {
+                context = this;
+                const check = checkSuperCalls(src, sourceFile(id), isComponentBase)
+                    .then(found => { if (found.length > 0)
+                    printDiagnostics(found); }, () => { })
+                    .finally(() => { pending.delete(check); });
+                pending.add(check);
+            }
             if (shouldLowerDecorators(id, src)) {
                 if (usesLegacyDecorators(sourceFile(id)))
                     return;
@@ -3314,6 +3927,7 @@ function lintProgram(program, files) {
             continue;
         if (wanted && !wanted.has(normalize(sf.fileName)))
             continue;
+        out.push(...superCallFindings(sf, checker));
         if (!/\.(tsx|jsx|mtsx|mjsx)$/.test(sf.fileName))
             continue;
         const visit = (node) => {
@@ -3369,6 +3983,60 @@ function lintProgram(program, files) {
     }
     return out;
 }
+const coreDeclarationFile = /[\\/](?:@motifx[\\/]core|motifjs[\\/](?:dist|src))[\\/]/;
+function derivesFromComponentBase(node, checker) {
+    try {
+        let type = checker.getTypeAtLocation(node);
+        const seen = new Set();
+        const queue = type ? [type] : [];
+        while (queue.length > 0) {
+            type = queue.shift();
+            const target = (type.target ?? type);
+            if (seen.has(target))
+                continue;
+            seen.add(target);
+            const sym = target.getSymbol();
+            if (sym && sym.getName() === 'ComponentBase' && sym.declarations?.some(d => coreDeclarationFile.test(d.getSourceFile().fileName)))
+                return true;
+            if (!(target.objectFlags & (ts__namespace.ObjectFlags.Class | ts__namespace.ObjectFlags.Interface)))
+                continue;
+            for (const b of checker.getBaseTypes(target) ?? [])
+                queue.push(b);
+        }
+    }
+    catch { }
+    return false;
+}
+function superCallFindings(sf, checker) {
+    if (!mayHaveSuperOverrides(sf.text))
+        return [];
+    const ast = parseModule(sf.text, sf.fileName);
+    if (!ast)
+        return [];
+    const findings = analyzeModule(ast).findings;
+    if (findings.length === 0)
+        return [];
+    const membersByLine = new Map();
+    const collect = (n) => {
+        if ((ts__namespace.isMethodDeclaration(n) || ts__namespace.isGetAccessorDeclaration(n) || ts__namespace.isSetAccessorDeclaration(n)) && (ts__namespace.isClassDeclaration(n.parent) || ts__namespace.isClassExpression(n.parent))) {
+            const name = n.name && (ts__namespace.isIdentifier(n.name) || ts__namespace.isStringLiteral(n.name)) ? n.name.text : '';
+            const lines = [n.getStart(sf), n.name.getStart(sf)].map(p => sf.getLineAndCharacterOfPosition(p).line + 1);
+            for (const l of lines)
+                membersByLine.set(`${l}:${name}`, n);
+        }
+        ts__namespace.forEachChild(n, collect);
+    };
+    collect(sf);
+    const out = [];
+    for (const f of findings) {
+        const member = membersByLine.get(`${f.line}:${f.member}`);
+        const cls = member?.parent;
+        if (!member || !cls || !derivesFromComponentBase(cls, checker))
+            continue;
+        out.push({ code: 'MJX015', file: sf.fileName, line: f.line, message: superCallMessage(f), frame: codeFrame(sf, member) });
+    }
+    return out;
+}
 /** tsconfig'den program kurup denetler. CLI bunu kullanır. */
 function lintProject(options = {}) {
     const projectPath = options.project ?? 'tsconfig.json';