@esportsplus/template 0.35.0 → 0.37.0

package/build/compiler/type-analyzer.js

@@ -1,193 +0,0 @@
-import { COMPILER_ENTRYPOINT, COMPILER_ENTRYPOINT_REACTIVITY, COMPILER_TYPES, DIRECT_ATTACH_EVENTS, LIFECYCLE_EVENTS } from '../constants.js';
-import { ts } from '@esportsplus/typescript';
-function analyzeSpread(expr, checker) {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-    if (ts.isObjectLiteralExpression(expr)) {
-        let keys = [];
-        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 = [], 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, checker) {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-    if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
-        return COMPILER_TYPES.Effect;
-    }
-    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.isArrayLiteralExpression(expr)) {
-        return COMPILER_TYPES.ArraySlot;
-    }
-    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;
-            }
-            if (isTypeArray(type, checker)) {
-                return COMPILER_TYPES.ArraySlot;
-            }
-        }
-        catch {
-        }
-    }
-    return COMPILER_TYPES.Unknown;
-}
-function isTypeArray(type, checker) {
-    if (checker.isArrayType(type)) {
-        return true;
-    }
-    return type.getSymbol()?.getName() === 'ReactiveArray';
-}
-function isTypeFunction(type, checker) {
-    if (type.getCallSignatures().length > 0) {
-        return true;
-    }
-    if (type.isUnion()) {
-        for (let i = 0, n = type.types.length; i < n; i++) {
-            if (isTypeFunction(type.types[i], checker)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-const analyzeExpression = (expr, checker) => {
-    return inferCOMPILER_TYPES(expr, checker);
-};
-const generateAttributeBinding = (elementVar, name, expr, staticValue, neededImports) => {
-    if (name.startsWith('on') && name.length > 2) {
-        let event = name.slice(2).toLowerCase(), key = name.toLowerCase();
-        if (LIFECYCLE_EVENTS.has(key)) {
-            neededImports.add(key);
-            return `${key}(${elementVar}, ${expr});`;
-        }
-        if (DIRECT_ATTACH_EVENTS.has(key)) {
-            neededImports.add('on');
-            return `on(${elementVar}, '${event}', ${expr});`;
-        }
-        neededImports.add('delegate');
-        return `delegate(${elementVar}, '${event}', ${expr});`;
-    }
-    if (name === 'class') {
-        neededImports.add('setClass');
-        return `setClass(${elementVar}, '${staticValue}', ${expr});`;
-    }
-    if (name === COMPILER_TYPES.Attributes) {
-        neededImports.add('setProperties');
-        return `setProperties(${elementVar}, ${expr});`;
-    }
-    if (name === 'style') {
-        neededImports.add('setStyle');
-        return `setStyle(${elementVar}, '${staticValue}', ${expr});`;
-    }
-    neededImports.add('setProperty');
-    return `setProperty(${elementVar}, '${name}', ${expr});`;
-};
-const generateSpreadBindings = (expr, exprCode, elementVar, checker, neededImports) => {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-    let analysis = analyzeSpread(expr, checker);
-    if (!analysis.canUnpack) {
-        neededImports.add('setProperties');
-        return [`setProperties(${elementVar}, ${exprCode});`];
-    }
-    let lines = [];
-    if (ts.isObjectLiteralExpression(expr)) {
-        for (let i = 0, n = analysis.keys.length; i < n; i++) {
-            let key = analysis.keys[i], value = 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, '', neededImports));
-            }
-        }
-    }
-    else {
-        for (let i = 0, n = analysis.keys.length; i < n; i++) {
-            let key = analysis.keys[i];
-            lines.push(generateAttributeBinding(elementVar, key, `${exprCode}.${key}`, '', neededImports));
-        }
-    }
-    return lines;
-};
-export { analyzeExpression, generateAttributeBinding, generateSpreadBindings };

package/src/compiler/type-analyzer.ts

@@ -1,274 +0,0 @@
-import {
-    COMPILER_ENTRYPOINT,
-    COMPILER_ENTRYPOINT_REACTIVITY,
-    COMPILER_TYPES,
-    DIRECT_ATTACH_EVENTS,
-    LIFECYCLE_EVENTS
-} 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;
-    }
-
-    if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
-        return COMPILER_TYPES.Effect;
-    }
-
-    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.isArrayLiteralExpression(expr)) {
-        return COMPILER_TYPES.ArraySlot;
-    }
-
-    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;
-            }
-
-            if (isTypeArray(type, checker)) {
-                return COMPILER_TYPES.ArraySlot;
-            }
-        }
-        catch {
-        }
-    }
-
-    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;
-    }
-
-    if (type.isUnion()) {
-        for (let i = 0, n = type.types.length; i < n; i++) {
-            if (isTypeFunction(type.types[i], checker)) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-
-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, neededImports: Set<string>): string => {
-    if (name.startsWith('on') && name.length > 2) {
-        let event = name.slice(2).toLowerCase(),
-            key = name.toLowerCase();
-
-        if (LIFECYCLE_EVENTS.has(key)) {
-            neededImports.add(key);
-            return `${key}(${elementVar}, ${expr});`;
-        }
-
-        if (DIRECT_ATTACH_EVENTS.has(key)) {
-            neededImports.add('on');
-            return `on(${elementVar}, '${event}', ${expr});`;
-        }
-
-        neededImports.add('delegate');
-        return `delegate(${elementVar}, '${event}', ${expr});`;
-    }
-
-    if (name === 'class') {
-        neededImports.add('setClass');
-        return `setClass(${elementVar}, '${staticValue}', ${expr});`;
-    }
-
-    if (name === COMPILER_TYPES.Attributes) {
-        neededImports.add('setProperties');
-        return `setProperties(${elementVar}, ${expr});`;
-    }
-
-    if (name === 'style') {
-        neededImports.add('setStyle');
-        return `setStyle(${elementVar}, '${staticValue}', ${expr});`;
-    }
-
-    neededImports.add('setProperty');
-    return `setProperty(${elementVar}, '${name}', ${expr});`;
-};
-
-const generateSpreadBindings = (
-    expr: ts.Expression,
-    exprCode: string,
-    elementVar: string,
-    checker: ts.TypeChecker | undefined,
-    neededImports: Set<string>
-): string[] => {
-    while (ts.isParenthesizedExpression(expr)) {
-        expr = expr.expression;
-    }
-
-    let analysis = analyzeSpread(expr, checker);
-
-    if (!analysis.canUnpack) {
-        neededImports.add('setProperties');
-        return [`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, '', neededImports));
-            }
-        }
-    }
-    else {
-        for (let i = 0, n = analysis.keys.length; i < n; i++) {
-            let key = analysis.keys[i];
-
-            lines.push(generateAttributeBinding(elementVar, key, `${exprCode}.${key}`, '', neededImports));
-        }
-    }
-
-    return lines;
-};
-
-
-export { analyzeExpression, generateAttributeBinding, generateSpreadBindings };