@esportsplus/reactivity 0.37.0 → 0.37.2

package/build/compiler/array.js

@@ -1,20 +1,7 @@
 import { ts } from '@esportsplus/typescript';
-import { ast } from '@esportsplus/typescript/compiler';
 import { COMPOUND_OPERATORS, NAMESPACE, TYPES } from './constants.js';
-function getElementTypeText(typeNode, sourceFile) {
-    if (ts.isArrayTypeNode(typeNode)) {
-        return typeNode.elementType.getText(sourceFile);
-    }
-    if (ts.isTypeReferenceNode(typeNode) &&
-        ts.isIdentifier(typeNode.typeName) &&
-        typeNode.typeName.text === 'Array' &&
-        typeNode.typeArguments &&
-        typeNode.typeArguments.length > 0) {
-        return typeNode.typeArguments[0].getText(sourceFile);
-    }
-    return null;
-}
-function visit(ctx, node) {
+import scope from './bindings.js';
+function declare(ctx, node) {
     if (ctx.isReactiveCall(node) && node.arguments.length > 0) {
         let arg = node.arguments[0], expression = ts.isAsExpression(arg) ? arg.expression : arg;
         if (ts.isArrayLiteralExpression(expression)) {
@@ -26,7 +13,7 @@ function visit(ctx, node) {
                 elementType = getElementTypeText(node.parent.type, ctx.sourceFile);
             }
             if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-                ctx.bindings.set(node.parent.name.text, TYPES.Array);
+                scope.declare(ctx.bindings, node.parent.name, TYPES.Array);
             }
             let typeParam = elementType ? `<${elementType}>` : '';
             ctx.replacements.push({
@@ -37,100 +24,107 @@ function visit(ctx, node) {
             });
         }
     }
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer) {
-        if (ts.isIdentifier(node.initializer) && ctx.bindings.get(node.initializer.text) === TYPES.Array) {
-            ctx.bindings.set(node.name.text, TYPES.Array);
-        }
-        if (ts.isPropertyAccessExpression(node.initializer)) {
-            let path = ast.property.path(node.initializer);
-            if (path && ctx.bindings.get(path) === TYPES.Array) {
-                ctx.bindings.set(node.name.text, TYPES.Array);
-            }
-        }
+    if (ts.isVariableDeclaration(node) &&
+        ts.isIdentifier(node.name) &&
+        node.initializer &&
+        (ts.isIdentifier(node.initializer) || ts.isPropertyAccessExpression(node.initializer)) &&
+        scope.isArray(ctx.bindings, node.initializer)) {
+        scope.declare(ctx.bindings, node.name, TYPES.Array);
     }
     if ((ts.isFunctionDeclaration(node) || ts.isArrowFunction(node)) && node.parameters) {
         for (let i = 0, n = node.parameters.length; i < n; i++) {
             let param = node.parameters[i];
-            if ((ts.isIdentifier(param.name) && param.type) &&
+            if (ts.isIdentifier(param.name) &&
+                param.type &&
                 ts.isTypeReferenceNode(param.type) &&
                 ts.isIdentifier(param.type.typeName) &&
                 param.type.typeName.text === 'ReactiveArray') {
-                ctx.bindings.set(param.name.text, TYPES.Array);
+                scope.declare(ctx.bindings, param.name, TYPES.Array);
             }
         }
     }
-    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length') {
-        let name = ast.expression.name(node.expression);
-        if (name && ctx.bindings.get(name) === TYPES.Array) {
-            let expr = node.expression, parent = node.parent;
-            if (parent && ts.isBinaryExpression(parent) && parent.left === node && (parent.operatorToken.kind === ts.SyntaxKind.EqualsToken || COMPOUND_OPERATORS.has(parent.operatorToken.kind))) {
-                let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind);
-                if (op === undefined) {
-                    ctx.replacements.push({
-                        node: parent,
-                        generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
-                    });
-                }
-                else {
-                    ctx.replacements.push({
-                        node: parent,
-                        generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
-                    });
-                }
-            }
-            else if (parent && ts.isPostfixUnaryExpression(parent)) {
-                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
-                ctx.replacements.push({
-                    node: parent,
-                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
-                });
-            }
-            else if (parent && ts.isPrefixUnaryExpression(parent)) {
-                let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+    node.forEachChild(child => declare(ctx, child));
+}
+function getElementTypeText(typeNode, sourceFile) {
+    if (ts.isArrayTypeNode(typeNode)) {
+        return typeNode.elementType.getText(sourceFile);
+    }
+    if (ts.isTypeReferenceNode(typeNode) &&
+        ts.isIdentifier(typeNode.typeName) &&
+        typeNode.typeName.text === 'Array' &&
+        typeNode.typeArguments &&
+        typeNode.typeArguments.length > 0) {
+        return typeNode.typeArguments[0].getText(sourceFile);
+    }
+    return null;
+}
+function rewrite(ctx, node) {
+    if (ts.isTypeNode(node)) {
+        return;
+    }
+    if (ts.isPropertyAccessExpression(node) && node.name.text === 'length' && scope.isArray(ctx.bindings, node.expression)) {
+        let expr = node.expression, parent = node.parent;
+        if (parent && ts.isBinaryExpression(parent) && parent.left === node && (parent.operatorToken.kind === ts.SyntaxKind.EqualsToken || COMPOUND_OPERATORS.has(parent.operatorToken.kind))) {
+            let op = COMPOUND_OPERATORS.get(parent.operatorToken.kind);
+            if (op === undefined) {
                 ctx.replacements.push({
                     node: parent,
-                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${parent.right.getText(sf)}`
                 });
             }
             else {
                 ctx.replacements.push({
-                    node,
-                    generate: (sf) => `${expr.getText(sf)}.$length`
+                    node: parent,
+                    generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} ${parent.right.getText(sf)}`
                 });
             }
         }
+        else if (parent && (ts.isPostfixUnaryExpression(parent) || ts.isPrefixUnaryExpression(parent))) {
+            let op = parent.operator === ts.SyntaxKind.PlusPlusToken ? '+' : '-';
+            ctx.replacements.push({
+                node: parent,
+                generate: (sf) => `${expr.getText(sf)}.$length = ${expr.getText(sf)}.length ${op} 1`
+            });
+        }
+        else {
+            ctx.replacements.push({
+                node,
+                generate: (sf) => `${expr.getText(sf)}.$length`
+            });
+        }
     }
     if (ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        ts.isElementAccessExpression(node.left)) {
-        let element = node.left, name = ast.expression.name(element.expression);
-        if (name && ctx.bindings.get(name) === TYPES.Array) {
-            ctx.replacements.push({
-                node,
-                generate: (sf) => `${element.expression.getText(sf)}.$set(
+        ts.isElementAccessExpression(node.left) &&
+        scope.isArray(ctx.bindings, node.left.expression)) {
+        let element = node.left;
+        ctx.replacements.push({
+            node,
+            generate: (sf) => `${element.expression.getText(sf)}.$set(
                     ${element.argumentExpression.getText(sf)},
                     ${node.right.getText(sf)}
                 )`
-            });
-        }
+        });
     }
     if (ts.isBinaryExpression(node) &&
         node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
-        ts.isIdentifier(node.left)) {
+        ts.isIdentifier(node.left) &&
+        scope.isArray(ctx.bindings, node.left)) {
         let name = node.left.text, right = node.right;
         while (ts.isAsExpression(right) || ts.isTypeAssertion(right)) {
             right = right.expression;
         }
-        if (ctx.bindings.get(name) === TYPES.Array && ts.isArrayLiteralExpression(right)) {
+        if (ts.isArrayLiteralExpression(right)) {
+            let elements = right;
             ctx.replacements.push({
                 node,
-                generate: (sf) => right.elements.length > 0
-                    ? `${name}.splice(0, ${name}.length, ...${right.getText(sf)})`
+                generate: (sf) => elements.elements.length > 0
+                    ? `${name}.splice(0, ${name}.length, ...${elements.getText(sf)})`
                     : `${name}.splice(0, ${name}.length)`
             });
         }
     }
-    node.forEachChild(n => visit(ctx, n));
+    node.forEachChild(child => rewrite(ctx, child));
 }
 export default (sourceFile, bindings, isReactiveCall) => {
     let ctx = {
@@ -139,6 +133,7 @@ export default (sourceFile, bindings, isReactiveCall) => {
         replacements: [],
         sourceFile
     };
-    visit(ctx, sourceFile);
+    declare(ctx, sourceFile);
+    rewrite(ctx, sourceFile);
     return ctx.replacements;
 };

package/build/compiler/bindings.d.ts

@@ -0,0 +1,19 @@
+import { ts } from '@esportsplus/typescript';
+import { TYPES } from './constants.js';
+import type { Bindings } from './types.js';
+declare const create: (checker: ts.Checker) => Bindings;
+declare const declare: (bindings: Bindings, identifier: ts.Identifier, type: TYPES) => void;
+declare const declarePath: (bindings: Bindings, identifier: ts.Identifier, path: string) => void;
+declare const isArray: (bindings: Bindings, expression: ts.Expression) => boolean;
+declare const resolve: (bindings: Bindings, identifier: ts.Identifier) => {
+    symbol: ts.Symbol;
+    type: TYPES;
+} | null;
+declare const _default: {
+    create: typeof create;
+    declare: typeof declare;
+    declarePath: typeof declarePath;
+    isArray: typeof isArray;
+    resolve: typeof resolve;
+};
+export default _default;

package/build/compiler/bindings.js

@@ -0,0 +1,65 @@
+import { ts } from '@esportsplus/typescript';
+import { TYPES } from './constants.js';
+function root(expression) {
+    let parts = [];
+    while (ts.isPropertyAccessExpression(expression)) {
+        parts.push(expression.name.text);
+        expression = expression.expression;
+    }
+    if (!ts.isIdentifier(expression) || parts.length === 0) {
+        return null;
+    }
+    return { path: parts.reverse().join('.'), root: expression };
+}
+function symbolOf(bindings, identifier) {
+    let parent = identifier.parent;
+    if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === identifier) {
+        return bindings.checker.getShorthandAssignmentValueSymbol(parent);
+    }
+    return bindings.checker.getSymbolAtLocation(identifier);
+}
+const create = (checker) => ({
+    checker,
+    names: new Set(),
+    paths: new Map(),
+    symbols: new Map()
+});
+const declare = (bindings, identifier, type) => {
+    let symbol = bindings.checker.getSymbolAtLocation(identifier);
+    if (symbol) {
+        bindings.names.add(identifier.text);
+        bindings.symbols.set(symbol, type);
+    }
+};
+const declarePath = (bindings, identifier, path) => {
+    let symbol = bindings.checker.getSymbolAtLocation(identifier);
+    if (!symbol) {
+        return;
+    }
+    let paths = bindings.paths.get(symbol);
+    if (!paths) {
+        paths = new Set();
+        bindings.paths.set(symbol, paths);
+    }
+    bindings.names.add(identifier.text);
+    paths.add(path);
+};
+const isArray = (bindings, expression) => {
+    if (ts.isIdentifier(expression)) {
+        return resolve(bindings, expression)?.type === TYPES.Array;
+    }
+    let access = root(expression);
+    if (!access || !bindings.names.has(access.root.text)) {
+        return false;
+    }
+    let symbol = symbolOf(bindings, access.root);
+    return symbol !== undefined && bindings.paths.get(symbol)?.has(access.path) === true;
+};
+const resolve = (bindings, identifier) => {
+    if (!bindings.names.has(identifier.text)) {
+        return null;
+    }
+    let symbol = symbolOf(bindings, identifier), type = symbol && bindings.symbols.get(symbol);
+    return symbol && type !== undefined ? { symbol, type } : null;
+};
+export default { create, declare, declarePath, isArray, resolve };

package/build/compiler/index.js

@@ -4,6 +4,13 @@ import { ENTRYPOINT, NAMESPACE, PACKAGE_NAME } from './constants.js';
 import array from './array.js';
 import object from './object.js';
 import primitives from './primitives.js';
+import scope from './bindings.js';
+function collect(checker, node, calls) {
+    if (isReactiveCallExpression(checker, node)) {
+        calls.add(node);
+    }
+    node.forEachChild(child => collect(checker, child, calls));
+}
 function isReactiveCallExpression(checker, node) {
     if (!ts.isCallExpression(node)) {
         return false;
@@ -12,8 +19,8 @@ function isReactiveCallExpression(checker, node) {
     if (ts.isIdentifier(expr)) {
         return imports.includes(checker, expr, PACKAGE_NAME, ENTRYPOINT);
     }
-    if (ts.isPropertyAccessExpression(expr) && expr.name.text === ENTRYPOINT) {
-        return imports.includes(checker, expr, PACKAGE_NAME);
+    if (ts.isPropertyAccessExpression(expr) && expr.name.text === ENTRYPOINT && ts.isIdentifier(expr.expression)) {
+        return imports.includes(checker, expr.expression, PACKAGE_NAME);
     }
     return false;
 }
@@ -24,15 +31,17 @@ export default {
         if (!checker) {
             return {};
         }
-        let bindings = new Map(), intents = {
+        let bindings = scope.create(checker), candidates = new Set(), intents = {
             imports: [],
             prepend: [],
             replacements: []
-        }, isReactiveCall = (node) => isReactiveCallExpression(checker, node), sourceFile = ctx.sourceFile;
-        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
-        if (calls.length === 0) {
+        }, sourceFile = ctx.sourceFile;
+        collect(checker, sourceFile, candidates);
+        if (candidates.size === 0) {
             return {};
         }
+        let isReactiveCall = (node) => candidates.has(node);
+        let { calls, replacements } = primitives(sourceFile, bindings, isReactiveCall);
         intents.replacements.push(...replacements);
         let objects = object(sourceFile, bindings, isReactiveCall);
         intents.prepend.push(...objects.prepend);

package/build/compiler/object.js

@@ -1,6 +1,7 @@
 import { ts } from '@esportsplus/typescript';
 import { code, uid } from '@esportsplus/typescript/compiler';
 import { NAMESPACE, TYPES } from './constants.js';
+import scope from './bindings.js';
 function analyzeProperty(prop, sourceFile) {
     if (!ts.isPropertyAssignment(prop)) {
         return null;
@@ -143,10 +144,9 @@ function visit(ctx, node) {
     if (ctx.isReactiveCall(node)) {
         let arg = node.arguments[0];
         if (arg && ts.isObjectLiteralExpression(arg)) {
-            let properties = [], props = arg.properties, varname = null;
-            if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-                varname = node.parent.name.text;
-            }
+            let properties = [], props = arg.properties, target = node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)
+                ? node.parent.name
+                : null, varname = target?.text ?? null;
             for (let i = 0, n = props.length; i < n; i++) {
                 let prop = props[i];
                 if (ts.isSpreadAssignment(prop)) {
@@ -159,8 +159,12 @@ function visit(ctx, node) {
                     return;
                 }
                 properties.push(analyzed);
-                if (analyzed.type === TYPES.Array && varname) {
-                    ctx.bindings.set(`${varname}.${analyzed.key}`, TYPES.Array);
+            }
+            if (target) {
+                for (let i = 0, n = properties.length; i < n; i++) {
+                    if (properties[i].type === TYPES.Array) {
+                        scope.declarePath(ctx.bindings, target, properties[i].key);
+                    }
                 }
             }
             ctx.calls.push({