@esportsplus/template 0.34.1 → 0.35.1

package/src/compiler/type-analyzer.ts

@@ -4,68 +4,10 @@ import {
     COMPILER_TYPES,
     DIRECT_ATTACH_EVENTS,
     LIFECYCLE_EVENTS
-} from '../constants';
+} from '~/constants';
 import { ts } from '@esportsplus/typescript';
 
 
-type SpreadAnalysis = {
-    canUnpack: boolean;
-    keys: string[];
-};
-
-
-function analyzeSpread(expr: ts.Expression, checker?: ts.TypeChecker): SpreadAnalysis {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-
-    if (ts.isObjectLiteralExpression(expr)) {
-        let keys: string[] = [];
-
-        for (let i = 0, n = expr.properties.length; i < n; i++) {
-            let prop = expr.properties[i];
-
-            if (ts.isPropertyAssignment(prop)) {
-                if (ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name)) {
-                    keys.push(prop.name.text);
-                }
-            }
-            else if (ts.isShorthandPropertyAssignment(prop)) {
-                keys.push(prop.name.text);
-            }
-            else if (ts.isSpreadAssignment(prop)) {
-                return { canUnpack: false, keys: [] };
-            }
-        }
-
-        return { canUnpack: true, keys };
-    }
-
-    if (checker && (ts.isIdentifier(expr) || ts.isPropertyAccessExpression(expr))) {
-        try {
-            let keys: string[] = [],
-                props = checker.getTypeAtLocation(expr).getProperties();
-
-            for (let i = 0, n = props.length; i < n; i++) {
-                let name = props[i].getName();
-
-                if (name.startsWith('__') || name.startsWith('[')) {
-                    continue;
-                }
-
-                keys.push(name);
-            }
-
-            if (keys.length > 0) {
-                return { canUnpack: true, keys };
-            }
-        }
-        catch { }
-    }
-
-    return { canUnpack: false, keys: [] };
-}
-
 function inferCOMPILER_TYPES(expr: ts.Expression, checker?: ts.TypeChecker): COMPILER_TYPES {
     while (ts.isParenthesizedExpression(expr)) {
         expr = expr.expression;
@@ -75,6 +17,7 @@ function inferCOMPILER_TYPES(expr: ts.Expression, checker?: ts.TypeChecker): COM
         return COMPILER_TYPES.Effect;
     }
 
+    // Only html.reactive() calls become ArraySlot - handled by generateReactiveInlining
     if (
         ts.isCallExpression(expr) &&
         ts.isPropertyAccessExpression(expr.expression) &&
@@ -89,10 +32,6 @@ function inferCOMPILER_TYPES(expr: ts.Expression, checker?: ts.TypeChecker): COM
         return COMPILER_TYPES.DocumentFragment;
     }
 
-    if (ts.isArrayLiteralExpression(expr)) {
-        return COMPILER_TYPES.ArraySlot;
-    }
-
     if (
         ts.isNumericLiteral(expr) ||
         ts.isStringLiteral(expr) ||
@@ -131,10 +70,6 @@ function inferCOMPILER_TYPES(expr: ts.Expression, checker?: ts.TypeChecker): COM
             if (isTypeFunction(type, checker)) {
                 return COMPILER_TYPES.Effect;
             }
-
-            if (isTypeArray(type, checker)) {
-                return COMPILER_TYPES.ArraySlot;
-            }
         }
         catch {
         }
@@ -143,28 +78,26 @@ function inferCOMPILER_TYPES(expr: ts.Expression, checker?: ts.TypeChecker): COM
     return COMPILER_TYPES.Unknown;
 }
 
-function isTypeArray(type: ts.Type, checker: ts.TypeChecker): boolean {
-    if (checker.isArrayType(type)) {
-        return true;
-    }
-
-    return type.getSymbol()?.getName() === 'ReactiveArray';
-}
-
 function isTypeFunction(type: ts.Type, checker: ts.TypeChecker): boolean {
-    if (type.getCallSignatures().length > 0) {
-        return true;
-    }
-
+    // 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)) {
-                return true;
+                hasFunction = true;
+            }
+            else {
+                allFunctions = false;
             }
         }
+
+        return hasFunction && allFunctions;
     }
 
-    return false;
+    return type.getCallSignatures().length > 0;
 }
 
 
@@ -172,94 +105,43 @@ const analyzeExpression = (expr: ts.Expression, checker?: ts.TypeChecker): COMPI
     return inferCOMPILER_TYPES(expr, checker);
 };
 
-const generateAttributeBinding = (elementVar: string, name: string, expr: string, staticValue: string, ns: string): string => {
+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 `${ns}.${key}(${elementVar}, ${expr});`;
+            return `${addImport(key)}(${elementVar}, ${expr});`;
         }
 
         if (DIRECT_ATTACH_EVENTS.has(key)) {
-            return `${ns}.on(${elementVar}, '${event}', ${expr});`;
+            return `${addImport('on')}(${elementVar}, '${event}', ${expr});`;
         }
 
-        return `${ns}.delegate(${elementVar}, '${event}', ${expr});`;
+        return `${addImport('delegate')}(${elementVar}, '${event}', ${expr});`;
     }
 
     if (name === 'class') {
-        return `${ns}.setClass(${elementVar}, '${staticValue}', ${expr});`;
+        return `${addImport('setClass')}(${elementVar}, '${staticValue}', ${expr});`;
     }
 
     if (name === COMPILER_TYPES.Attributes) {
-        return `${ns}.setProperties(${elementVar}, ${expr});`;
+        return `${addImport('setProperties')}(${elementVar}, ${expr});`;
     }
 
     if (name === 'style') {
-        return `${ns}.setStyle(${elementVar}, '${staticValue}', ${expr});`;
+        return `${addImport('setStyle')}(${elementVar}, '${staticValue}', ${expr});`;
     }
 
-    return `${ns}.setProperty(${elementVar}, '${name}', ${expr});`;
+    return `${addImport('setProperty')}(${elementVar}, '${name}', ${expr});`;
 };
 
 const generateSpreadBindings = (
-    expr: ts.Expression,
     exprCode: string,
     elementVar: string,
-    checker: ts.TypeChecker | undefined,
-    ns: string
+    addImport: (name: string) => string
 ): string[] => {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-
-    let analysis = analyzeSpread(expr, checker);
-
-    if (!analysis.canUnpack) {
-        return [`${ns}.setProperties(${elementVar}, ${exprCode});`];
-    }
-
-    let lines: string[] = [];
-
-    if (ts.isObjectLiteralExpression(expr)) {
-        for (let i = 0, n = analysis.keys.length; i < n; i++) {
-            let key = analysis.keys[i],
-                value: string | null = null;
-
-            for (let j = 0, m = expr.properties.length; j < m; j++) {
-                let prop = expr.properties[j];
-
-                if (ts.isPropertyAssignment(prop)) {
-                    let text = ts.isIdentifier(prop.name)
-                            ? prop.name.text
-                            : ts.isStringLiteral(prop.name) ? prop.name.text : null;
-
-                    if (text === key) {
-                        value = prop.initializer.getText();
-                        break;
-                    }
-                }
-                else if (ts.isShorthandPropertyAssignment(prop) && prop.name.text === key) {
-                    value = prop.name.text;
-                    break;
-                }
-            }
-
-            if (value !== null) {
-                lines.push(generateAttributeBinding(elementVar, key, value, '', ns));
-            }
-        }
-    }
-    else {
-        for (let i = 0, n = analysis.keys.length; i < n; i++) {
-            let key = analysis.keys[i];
-
-            lines.push(generateAttributeBinding(elementVar, key, `${exprCode}.${key}`, '', ns));
-        }
-    }
-
-    return lines;
+    return [`${addImport('setProperties')}(${elementVar}, ${exprCode});`];
 };
 
 

package/src/constants.ts

@@ -1,17 +1,11 @@
-import { uid } from '@esportsplus/typescript/compiler';
-
-
 const ARRAY_SLOT = Symbol('template.array.slot');
 
 const CLEANUP = Symbol('template.cleanup');
 
-
 const COMPILER_ENTRYPOINT = 'html';
 
 const COMPILER_ENTRYPOINT_REACTIVITY = 'reactive';
 
-const COMPILER_NAMESPACE = uid('template');
-
 const enum COMPILER_TYPES {
     ArraySlot = 'array-slot',
     Attributes = 'attributes',
@@ -40,9 +34,6 @@ const LIFECYCLE_EVENTS = new Set<string>([
 
 const PACKAGE = '@esportsplus/template';
 
-const PACKAGE_COMPILER = '@esportsplus/template/compiler';
-
-
 const SLOT_HTML = '<!--$-->';
 
 const STATE_HYDRATING = 0;
@@ -57,9 +48,9 @@ const STORE = Symbol('template.store');
 export {
     ARRAY_SLOT,
     CLEANUP,
-    COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_NAMESPACE, COMPILER_TYPES,
+    COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES,
     DIRECT_ATTACH_EVENTS,
     LIFECYCLE_EVENTS,
-    PACKAGE, PACKAGE_COMPILER,
+    PACKAGE,
     SLOT_HTML, STATE_HYDRATING, STATE_NONE, STATE_WAITING, STORE,
-};
+};

package/src/index.ts

@@ -1,5 +1,20 @@
-import './runtime';
+import { CLEANUP, STORE } from './constants';
+
+
+// Pre-allocate on Node prototype to optimize property access
+if (typeof Node !== 'undefined') {
+    (Node.prototype as any)[CLEANUP] = null;
+    (Node.prototype as any)[STORE] = null;
+}
+
+
 export { default as html } from './html';
 export { default as render } from './render';
 export { default as svg } from './svg';
+export * from './attributes';
+export * from './event';
+export { ArraySlot } from './slot/array';
+export { EffectSlot } from './slot/effect';
+export { default as slot } from './slot';
 export type { Attributes, Element, Renderable } from './types';
+export * from './utilities';

package/src/utilities.ts

@@ -1,8 +1,8 @@
 import { SLOT_HTML } from './constants';
 
 
-let tmpl = document?.createElement('template'),
-    txt = document?.createTextNode('');
+let tmpl = document.createElement('template'),
+    txt = document.createTextNode('');
 
 
 // Firefox's importNode outperforms cloneNode in certain scenarios

package/test/vite.config.ts

@@ -1,7 +1,7 @@
 import { defineConfig } from 'vite';
 import { resolve } from 'path';
 import tsconfigPaths from 'vite-tsconfig-paths';
-import templatePlugin from '../src/compiler/vite';
+import templatePlugin from '../src/compiler/plugins/vite';
 
 
 export default defineConfig({

package/build/runtime.d.ts

@@ -1 +0,0 @@
-export {};

package/build/runtime.js

@@ -1,5 +0,0 @@
-import { CLEANUP, STORE } from './constants.js';
-if (typeof Node !== 'undefined') {
-    Node.prototype[CLEANUP] = null;
-    Node.prototype[STORE] = null;
-}

package/src/runtime.ts

@@ -1,8 +0,0 @@
-import { CLEANUP, STORE } from './constants';
-
-
-// Pre-allocate on Node prototype to optimize property access
-if (typeof Node !== 'undefined') {
-    (Node.prototype as any)[CLEANUP] = null;
-    (Node.prototype as any)[STORE] = null;
-}