@esportsplus/template 0.35.1 → 0.38.0

package/src/compiler/ts-parser.ts

@@ -50,10 +50,10 @@ function isHtmlFromPackage(node: ts.Identifier, checker: ts.TypeChecker | undefi
 
     // Check if any declaration is from our package
     for (let i = 0, n = declarations.length; i < n; i++) {
-        let fileName = declarations[i].getSourceFile().fileName;
+        let filename = declarations[i].getSourceFile().fileName;
 
         // Check for package in node_modules path or direct package reference
-        if (fileName.includes(PACKAGE) || fileName.includes('@esportsplus/template')) {
+        if (filename.includes(PACKAGE) || filename.includes('@esportsplus/template')) {
             return true;
         }
     }

package/test/vite.config.ts

@@ -19,7 +19,7 @@ export default defineConfig({
                 'templates': resolve(__dirname, 'templates.ts')
             },
             formats: ['es'],
-            fileName: (_, entryName) => `${entryName}.js`
+            filename: (_, entryName) => `${entryName}.js`
         },
         outDir: resolve(__dirname, 'build'),
         emptyOutDir: true,

package/build/compiler/type-analyzer.d.ts

@@ -1,6 +0,0 @@
-import { COMPILER_TYPES } from '../constants.js';
-import { ts } from '@esportsplus/typescript';
-declare const analyzeExpression: (expr: ts.Expression, checker?: ts.TypeChecker) => COMPILER_TYPES;
-declare const generateAttributeBinding: (elementVar: string, name: string, expr: string, staticValue: string, addImport: (name: string) => string) => string;
-declare const generateSpreadBindings: (exprCode: string, elementVar: string, addImport: (name: string) => string) => string[];
-export { analyzeExpression, generateAttributeBinding, generateSpreadBindings };

package/src/compiler/type-analyzer.ts

@@ -1,148 +0,0 @@
-import {
-    COMPILER_ENTRYPOINT,
-    COMPILER_ENTRYPOINT_REACTIVITY,
-    COMPILER_TYPES,
-    DIRECT_ATTACH_EVENTS,
-    LIFECYCLE_EVENTS
-} from '~/constants';
-import { ts } from '@esportsplus/typescript';
-
-
-function inferCOMPILER_TYPES(expr: ts.Expression, checker?: ts.TypeChecker): COMPILER_TYPES {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-
-    if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
-        return COMPILER_TYPES.Effect;
-    }
-
-    // Only html.reactive() calls become ArraySlot - handled by generateReactiveInlining
-    if (
-        ts.isCallExpression(expr) &&
-        ts.isPropertyAccessExpression(expr.expression) &&
-        ts.isIdentifier(expr.expression.expression) &&
-        expr.expression.expression.text === COMPILER_ENTRYPOINT &&
-        expr.expression.name.text === COMPILER_ENTRYPOINT_REACTIVITY
-    ) {
-        return COMPILER_TYPES.ArraySlot;
-    }
-
-    if (ts.isTaggedTemplateExpression(expr) && ts.isIdentifier(expr.tag) && expr.tag.text === COMPILER_ENTRYPOINT) {
-        return COMPILER_TYPES.DocumentFragment;
-    }
-
-    if (
-        ts.isNumericLiteral(expr) ||
-        ts.isStringLiteral(expr) ||
-        ts.isNoSubstitutionTemplateLiteral(expr) ||
-        expr.kind === ts.SyntaxKind.TrueKeyword ||
-        expr.kind === ts.SyntaxKind.FalseKeyword ||
-        expr.kind === ts.SyntaxKind.NullKeyword ||
-        expr.kind === ts.SyntaxKind.UndefinedKeyword
-    ) {
-        return COMPILER_TYPES.Static;
-    }
-
-    if (ts.isTemplateExpression(expr)) {
-        return COMPILER_TYPES.Primitive;
-    }
-
-    if (ts.isConditionalExpression(expr)) {
-        let whenFalse = inferCOMPILER_TYPES(expr.whenFalse, checker),
-            whenTrue = inferCOMPILER_TYPES(expr.whenTrue, checker);
-
-        if (whenTrue === whenFalse) {
-            return whenTrue;
-        }
-
-        if (whenTrue === COMPILER_TYPES.Effect || whenFalse === COMPILER_TYPES.Effect) {
-            return COMPILER_TYPES.Effect;
-        }
-
-        return COMPILER_TYPES.Unknown;
-    }
-
-    if (checker && (ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr) || ts.isCallExpression(expr))) {
-        try {
-            let type = checker.getTypeAtLocation(expr);
-
-            if (isTypeFunction(type, checker)) {
-                return COMPILER_TYPES.Effect;
-            }
-        }
-        catch {
-        }
-    }
-
-    return COMPILER_TYPES.Unknown;
-}
-
-function isTypeFunction(type: ts.Type, checker: ts.TypeChecker): boolean {
-    // Union types that mix functions with non-functions (e.g., Renderable)
-    // should fall through to runtime slot dispatch
-    if (type.isUnion()) {
-        let allFunctions = true,
-            hasFunction = false;
-
-        for (let i = 0, n = type.types.length; i < n; i++) {
-            if (isTypeFunction(type.types[i], checker)) {
-                hasFunction = true;
-            }
-            else {
-                allFunctions = false;
-            }
-        }
-
-        return hasFunction && allFunctions;
-    }
-
-    return type.getCallSignatures().length > 0;
-}
-
-
-const analyzeExpression = (expr: ts.Expression, checker?: ts.TypeChecker): COMPILER_TYPES => {
-    return inferCOMPILER_TYPES(expr, checker);
-};
-
-const generateAttributeBinding = (elementVar: string, name: string, expr: string, staticValue: string, addImport: (name: string) => string): string => {
-    if (name.startsWith('on') && name.length > 2) {
-        let event = name.slice(2).toLowerCase(),
-            key = name.toLowerCase();
-
-        if (LIFECYCLE_EVENTS.has(key)) {
-            return `${addImport(key)}(${elementVar}, ${expr});`;
-        }
-
-        if (DIRECT_ATTACH_EVENTS.has(key)) {
-            return `${addImport('on')}(${elementVar}, '${event}', ${expr});`;
-        }
-
-        return `${addImport('delegate')}(${elementVar}, '${event}', ${expr});`;
-    }
-
-    if (name === 'class') {
-        return `${addImport('setClass')}(${elementVar}, '${staticValue}', ${expr});`;
-    }
-
-    if (name === COMPILER_TYPES.Attributes) {
-        return `${addImport('setProperties')}(${elementVar}, ${expr});`;
-    }
-
-    if (name === 'style') {
-        return `${addImport('setStyle')}(${elementVar}, '${staticValue}', ${expr});`;
-    }
-
-    return `${addImport('setProperty')}(${elementVar}, '${name}', ${expr});`;
-};
-
-const generateSpreadBindings = (
-    exprCode: string,
-    elementVar: string,
-    addImport: (name: string) => string
-): string[] => {
-    return [`${addImport('setProperties')}(${elementVar}, ${exprCode});`];
-};
-
-
-export { analyzeExpression, generateAttributeBinding, generateSpreadBindings };