@jay-framework/compiler 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -3,9 +3,127 @@ import * as ts from 'typescript';
 import { JayHtmlSourceFile } from '@jay-framework/compiler-jay-html';
 export { generateElementDefinitionFile } from '@jay-framework/compiler-jay-html';
 
+declare enum VariableRootType {
+    FunctionParameter = 0,
+    FunctionDefinition = 1,
+    Literal = 2,
+    ImportModule = 3,
+    FunctionCall = 4,
+    Global = 5,
+    Other = 6
+}
+interface VariableRoot {
+    kind: VariableRootType;
+}
+interface ParamVariableRoot extends VariableRoot {
+    kind: VariableRootType.FunctionParameter;
+    paramIndex: number;
+    param: ts.ParameterDeclaration;
+}
+declare function mkParameterVariableRoot(param: ts.ParameterDeclaration, paramIndex: number): ParamVariableRoot;
+interface FunctionVariableRoot extends VariableRoot {
+    kind: VariableRootType.FunctionDefinition;
+    func: ts.FunctionLikeDeclarationBase;
+}
+declare function mkFunctionVariableRoot(func: ts.FunctionLikeDeclarationBase): FunctionVariableRoot;
+interface LiteralVariableRoot extends VariableRoot {
+    kind: VariableRootType.Literal;
+    literal: ts.Expression;
+}
+declare function mkLiteralVariableRoot(literal: ts.Expression): LiteralVariableRoot;
+declare enum ImportType {
+    defaultImport = 0,
+    namedImport = 1
+}
+interface ImportModuleVariableRoot extends VariableRoot {
+    kind: VariableRootType.ImportModule;
+    module: ts.Expression;
+    importType: ImportType;
+}
+declare function mkImportModuleVariableRoot(module: ts.Expression, importType: ImportType): ImportModuleVariableRoot;
+interface FunctionCallVariableRoot extends VariableRoot {
+    kind: VariableRootType.FunctionCall;
+    node: ts.CallExpression;
+}
+declare function mkFunctionCallVariableRoot(node: ts.CallExpression): FunctionCallVariableRoot;
+interface GlobalVariableRoot extends VariableRoot {
+    kind: VariableRootType.Global;
+    name: string;
+}
+declare function mkGlobalVariableRoot(name: string): GlobalVariableRoot;
+interface OtherVariableRoot extends VariableRoot {
+    kind: VariableRootType.Other;
+    node: ts.Node;
+}
+declare function mkOtherVariableRoot(node: ts.Node): OtherVariableRoot;
+declare function isParamVariableRoot(vr: VariableRoot): vr is ParamVariableRoot;
+declare function isFunctionVariableRoot(vr: VariableRoot): vr is FunctionVariableRoot;
+declare function isImportModuleVariableRoot(vr: VariableRoot): vr is ImportModuleVariableRoot;
+declare function isLiteralVariableRoot(vr: VariableRoot): vr is LiteralVariableRoot;
+declare function isFunctionCallVariableRoot(vr: VariableRoot): vr is FunctionCallVariableRoot;
+declare function isGlobalVariableRoot(vr: VariableRoot): vr is GlobalVariableRoot;
+declare function isOtherVariableRoot(vr: VariableRoot): vr is OtherVariableRoot;
+declare enum LetOrConst {
+    LET = 0,
+    CONST = 1
+}
+interface Variable {
+    name?: string;
+    letOrConst?: LetOrConst;
+    definingStatement?: ts.Statement;
+    accessedFrom?: Variable;
+    accessedByProperty?: string;
+    assignedFrom?: Variable;
+    root?: VariableRoot;
+    properties?: Variable[];
+}
+declare function mkVariable(members: {
+    name?: string;
+    letOrConst?: LetOrConst;
+    definingStatement?: ts.Statement;
+    accessedFrom?: Variable;
+    accessedByProperty?: string;
+    assignedFrom?: Variable;
+    root?: VariableRoot;
+    properties?: Variable[];
+}): {
+    [k: string]: string | ts.Statement | VariableRoot | Variable | LetOrConst | Variable[];
+};
+declare const UNKNOWN_VARIABLE: Variable;
+declare function tsBindingNameToVariable(binding: ts.BindingName, accessedFrom?: Variable, assignedFrom?: Variable, propertyName?: ts.PropertyName, root?: ParamVariableRoot): Variable[];
+declare class NameBindingResolver {
+    readonly parentNameResolver?: NameBindingResolver;
+    constructor(parentNameResolver?: NameBindingResolver);
+    variables: Map<string, Variable>;
+    addVariable(name: string, variable: Variable): void;
+    addFunctionParams(functionDeclaration: ts.FunctionLikeDeclarationBase): void;
+    addFunctionDeclaration(statement: ts.FunctionDeclaration): void;
+    addVariableDeclarationList(declarationList: ts.VariableDeclarationList): void;
+    addVariableStatement(variableStatement: ts.VariableStatement): void;
+    getVariable(name: string): Variable;
+    resolvePropertyAccessChain(expression: ts.Expression): Variable;
+    resolvePropertyAccess(expression: ts.PropertyAccessExpression): Variable;
+    resolveIdentifier(expression: ts.Identifier): Variable;
+    addImportDeclaration(node: ts.ImportDeclaration): void;
+}
+interface FlattenedAccessChain {
+    path: string[];
+    root: VariableRoot;
+}
+declare function flattenVariable(variable: Variable, path?: string[]): FlattenedAccessChain;
+
 interface ResolvedType {
     canBeAssignedFrom(rightSide: ResolvedType): any;
 }
+declare class SourceFileBindingResolver {
+    private nameBindingResolvers;
+    constructor(sourceFile: ts.SourceFile);
+    findBindingResolver(node: ts.Node): NameBindingResolver;
+    explain(identifier: ts.Identifier | ts.PropertyAccessExpression): Variable;
+    explainFlattenedVariableType(flattened: FlattenedAccessChain): ResolvedType;
+    explainType(type: ts.TypeNode): ResolvedType;
+    globalType(globalVariableRoot: GlobalVariableRoot): ResolvedType;
+}
 
 declare enum CompilePatternType {
     RETURN = 0,
@@ -71,6 +189,39 @@ declare function createTsSourceFileFromSource(filePath: string, sourceCode: stri
 
 declare function transformComponentImports(needsHandler$: boolean, needsFunc$: boolean, needsFuncGlobal$: boolean, transformedSourceFile: ts.SourceFile, context: ts.TransformationContext, factory: ts.NodeFactory, sourceFile: ts.SourceFile): ts.SourceFile;
 
+interface StatementDependencies {
+    id: number;
+    parent?: ts.Statement;
+    statement: ts.Statement;
+    dependsOn: Set<StatementDependencies>;
+    isDependencyFor: Set<StatementDependencies>;
+}
+declare class SourceFileStatementDependencies {
+    private statementDependencies;
+    constructor(sourceFile: ts.SourceFile, bindingResolver: SourceFileBindingResolver);
+    getDependsOn(statement: ts.Statement): Set<StatementDependencies>;
+    getIsDependencyFor(statement: ts.Statement): Set<StatementDependencies>;
+    getAllStatements(): IterableIterator<StatementDependencies>;
+    getStatementDependencies(statement: ts.Statement): StatementDependencies;
+}
+
+interface SourceFileTransformerContext {
+    factory: ts.NodeFactory;
+    context: ts.TransformationContext;
+    sourceFile: ts.SourceFile;
+}
+type SourceFileTransformer<S extends SourceFileTransformerContext> = (data: SourceFileTransformerContext) => ts.SourceFile;
+declare function mkTransformer<C extends object>(fileTransformer: SourceFileTransformer<C & SourceFileTransformerContext>, config?: C): ts.TransformerFactory<ts.SourceFile>;
+
+/**
+ * Compare two FlattenedAccessChain objects for equality
+ *
+ * Two chains are equal if:
+ * 1. Their paths are identical (same length, same elements in order)
+ * 2. Their roots refer to the same source
+ */
+declare function areFlattenedAccessChainsEqual(chain1: FlattenedAccessChain, chain2: FlattenedAccessChain): boolean;
+
 declare function generateElementFile(jayFile: JayHtmlSourceFile, importerMode: MainRuntimeModes, generateTarget?: GenerateTarget): WithValidations<string>;
 
-export { type CompiledPattern, FunctionRepositoryBuilder, compileFunctionSplitPatternsBlock, createTsSourceFileFromSource, extractImportDeclarations, extractImportedModules, generateElementFile, generateImportsFileFromJayFile, generateImportsFileFromTsSource, getImportName, getImportSpecifiers, isRelativeImport, parseGenericTypescriptFile, transformComponent, transformComponentBridge, transformComponentImports };
+export { type CompiledPattern, type FlattenedAccessChain, type FunctionCallVariableRoot, FunctionRepositoryBuilder, type FunctionVariableRoot, type GlobalVariableRoot, type ImportModuleVariableRoot, ImportType, LetOrConst, type LiteralVariableRoot, NameBindingResolver, type OtherVariableRoot, type ParamVariableRoot, SourceFileBindingResolver, SourceFileStatementDependencies, type SourceFileTransformerContext, UNKNOWN_VARIABLE, type Variable, type VariableRoot, VariableRootType, areFlattenedAccessChainsEqual, compileFunctionSplitPatternsBlock, createTsSourceFileFromSource, extractImportDeclarations, extractImportedModules, flattenVariable, generateElementFile, generateImportsFileFromJayFile, generateImportsFileFromTsSource, getImportName, getImportSpecifiers, isFunctionCallVariableRoot, isFunctionVariableRoot, isGlobalVariableRoot, isImportModuleVariableRoot, isLiteralVariableRoot, isOtherVariableRoot, isParamVariableRoot, isRelativeImport, mkFunctionCallVariableRoot, mkFunctionVariableRoot, mkGlobalVariableRoot, mkImportModuleVariableRoot, mkLiteralVariableRoot, mkOtherVariableRoot, mkParameterVariableRoot, mkTransformer, mkVariable, parseGenericTypescriptFile, transformComponent, transformComponentBridge, transformComponentImports, tsBindingNameToVariable };

package/dist/index.js

@@ -56,7 +56,7 @@ function mkTransformer(fileTransformer, config) {
     };
   };
 }
-const { isStringLiteral: isStringLiteral$9, isImportDeclaration: isImportDeclaration$5, forEachChild: forEachChild$4, isNamedImports: isNamedImports$1 } = c;
+const { isStringLiteral: isStringLiteral$a, isImportDeclaration: isImportDeclaration$5, forEachChild: forEachChild$4, isNamedImports: isNamedImports$1 } = c;
 function extractImportDeclarations(sourceFile) {
   const importDeclarations = [];
   function visit(node) {
@@ -69,7 +69,7 @@ function extractImportDeclarations(sourceFile) {
   return importDeclarations;
 }
 function extractImportedModules(sourceFile) {
-  return extractImportDeclarations(sourceFile).filter((node) => isStringLiteral$9(node.moduleSpecifier)).map((node) => node.moduleSpecifier.text);
+  return extractImportDeclarations(sourceFile).filter((node) => isStringLiteral$a(node.moduleSpecifier)).map((node) => node.moduleSpecifier.text);
 }
 function isRelativeImport(module) {
   return module.startsWith(".");
@@ -81,9 +81,9 @@ function getImportSpecifiers(importDeclaration) {
 function getImportName(importSpecifier) {
   return importSpecifier.propertyName?.text ?? importSpecifier.name.text;
 }
-const { isStringLiteral: isStringLiteral$8, forEachChild: forEachChild$3, isImportDeclaration: isImportDeclaration$4 } = c;
+const { isStringLiteral: isStringLiteral$9, forEachChild: forEachChild$3, isImportDeclaration: isImportDeclaration$4 } = c;
 function findMakeJayComponentImport(makeJayComponentName, node) {
-  if (isImportDeclaration$4(node) && isStringLiteral$8(node.moduleSpecifier) && node.moduleSpecifier.text === JAY_COMPONENT) {
+  if (isImportDeclaration$4(node) && isStringLiteral$9(node.moduleSpecifier) && node.moduleSpecifier.text === JAY_COMPONENT) {
     let importSpecifier = getImportSpecifiers(node)?.find(
       (element) => getImportName(element) === makeJayComponentName
     );
@@ -93,11 +93,11 @@ function findMakeJayComponentImport(makeJayComponentName, node) {
   }
   return void 0;
 }
-const { isIdentifier: isIdentifier$9, isArrowFunction: isArrowFunction$3, isFunctionDeclaration: isFunctionDeclaration$2, isVariableStatement: isVariableStatement$3, forEachChild: forEachChild$2 } = c;
+const { isIdentifier: isIdentifier$a, isArrowFunction: isArrowFunction$3, isFunctionDeclaration: isFunctionDeclaration$2, isVariableStatement: isVariableStatement$3, forEachChild: forEachChild$2 } = c;
 function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile) {
   const foundConstructors = [];
   const namedConstructors = new Set(
-    componentFunctionExpressions.filter((expression) => isIdentifier$9(expression)).map((expression) => isIdentifier$9(expression) && expression.text)
+    componentFunctionExpressions.filter((expression) => isIdentifier$a(expression)).map((expression) => isIdentifier$a(expression) && expression.text)
   );
   const inlineConstructors = componentFunctionExpressions.filter(
     isFunctionLikeDeclarationBase
@@ -108,7 +108,7 @@ function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile
         foundConstructors.push(node);
     } else if (isVariableStatement$3(node)) {
       node.declarationList.declarations.forEach((declaration) => {
-        if (isIdentifier$9(declaration.name) && namedConstructors.has(declaration.name.text) && declaration.initializer && isArrowFunction$3(declaration.initializer))
+        if (isIdentifier$a(declaration.name) && namedConstructors.has(declaration.name.text) && declaration.initializer && isArrowFunction$3(declaration.initializer))
           foundConstructors.push(declaration.initializer);
       });
     }
@@ -118,14 +118,14 @@ function findComponentConstructorsBlock(componentFunctionExpressions, sourceFile
   return [...foundConstructors, ...inlineConstructors];
 }
 const {
-  isIdentifier: isIdentifier$8,
-  isStatement: isStatement$2,
+  isIdentifier: isIdentifier$9,
+  isStatement: isStatement$3,
   isObjectBindingPattern,
   isArrayBindingPattern,
   isBindingElement,
   isPropertyAccessExpression: isPropertyAccessExpression$5,
   isElementAccessExpression: isElementAccessExpression$1,
-  isStringLiteral: isStringLiteral$7,
+  isStringLiteral: isStringLiteral$8,
   isParenthesizedExpression,
   isAsExpression,
   isObjectLiteralExpression,
@@ -141,6 +141,16 @@ const {
   NodeFlags,
   SyntaxKind: SyntaxKind$5
 } = c;
+var VariableRootType = /* @__PURE__ */ ((VariableRootType2) => {
+  VariableRootType2[VariableRootType2["FunctionParameter"] = 0] = "FunctionParameter";
+  VariableRootType2[VariableRootType2["FunctionDefinition"] = 1] = "FunctionDefinition";
+  VariableRootType2[VariableRootType2["Literal"] = 2] = "Literal";
+  VariableRootType2[VariableRootType2["ImportModule"] = 3] = "ImportModule";
+  VariableRootType2[VariableRootType2["FunctionCall"] = 4] = "FunctionCall";
+  VariableRootType2[VariableRootType2["Global"] = 5] = "Global";
+  VariableRootType2[VariableRootType2["Other"] = 6] = "Other";
+  return VariableRootType2;
+})(VariableRootType || {});
 function mkParameterVariableRoot(param, paramIndex) {
   return { kind: 0, param, paramIndex };
 }
@@ -150,6 +160,11 @@ function mkFunctionVariableRoot(func) {
 function mkLiteralVariableRoot(literal) {
   return { kind: 2, literal };
 }
+var ImportType = /* @__PURE__ */ ((ImportType2) => {
+  ImportType2[ImportType2["defaultImport"] = 0] = "defaultImport";
+  ImportType2[ImportType2["namedImport"] = 1] = "namedImport";
+  return ImportType2;
+})(ImportType || {});
 function mkImportModuleVariableRoot(module, importType) {
   return { kind: 3, module, importType };
 }
@@ -180,6 +195,9 @@ function isFunctionCallVariableRoot(vr) {
 function isGlobalVariableRoot(vr) {
   return vr.kind === 5;
 }
+function isOtherVariableRoot(vr) {
+  return vr.kind === 6;
+}
 var LetOrConst = /* @__PURE__ */ ((LetOrConst2) => {
   LetOrConst2[LetOrConst2["LET"] = 0] = "LET";
   LetOrConst2[LetOrConst2["CONST"] = 1] = "CONST";
@@ -190,18 +208,18 @@ function mkVariable(members) {
 }
 const UNKNOWN_VARIABLE = {};
 const getAccessedByProperty = (binding, accessedFrom, propertyName) => {
-  return accessedFrom ? propertyName ? isIdentifier$8(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
+  return accessedFrom ? propertyName ? isIdentifier$9(propertyName) ? propertyName.text : void 0 : binding.text : void 0;
 };
 function findDeclaringStatement(node) {
   if (!node)
     return void 0;
-  else if (isStatement$2(node))
+  else if (isStatement$3(node))
     return node;
   else
     return findDeclaringStatement(node.parent);
 }
 function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyName, root) {
-  if (isIdentifier$8(binding)) {
+  if (isIdentifier$9(binding)) {
     return [
       mkVariable({
         name: binding.text,
@@ -215,7 +233,7 @@ function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyNa
   } else if (isObjectBindingPattern(binding)) {
     let variable = mkVariable({
       accessedFrom,
-      accessedByProperty: propertyName ? isIdentifier$8(propertyName) ? propertyName.text : void 0 : void 0,
+      accessedByProperty: propertyName ? isIdentifier$9(propertyName) ? propertyName.text : void 0 : void 0,
       assignedFrom,
       root,
       definingStatement: findDeclaringStatement(binding)
@@ -226,7 +244,7 @@ function tsBindingNameToVariable(binding, accessedFrom, assignedFrom, propertyNa
   } else if (isArrayBindingPattern(binding)) {
     let variable = mkVariable({
       accessedFrom,
-      accessedByProperty: propertyName ? isIdentifier$8(propertyName) ? propertyName.text : void 0 : void 0,
+      accessedByProperty: propertyName ? isIdentifier$9(propertyName) ? propertyName.text : void 0 : void 0,
       assignedFrom,
       root,
       definingStatement: findDeclaringStatement(binding)
@@ -298,11 +316,11 @@ class NameBindingResolver {
       const name = expression.name.text;
       const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
       return { accessedFrom: identifiersFromObject, accessedByProperty: name };
-    } else if (isElementAccessExpression$1(expression) && isStringLiteral$7(expression.argumentExpression)) {
+    } else if (isElementAccessExpression$1(expression) && isStringLiteral$8(expression.argumentExpression)) {
       const name = expression.argumentExpression.text;
       const identifiersFromObject = this.resolvePropertyAccessChain(expression.expression);
       return { accessedFrom: identifiersFromObject, accessedByProperty: name };
-    } else if (isIdentifier$8(expression)) {
+    } else if (isIdentifier$9(expression)) {
       return this.resolveIdentifier(expression);
     } else if (isParenthesizedExpression(expression)) {
       return this.resolvePropertyAccessChain(expression.expression);
@@ -311,8 +329,8 @@ class NameBindingResolver {
     } else if (isObjectLiteralExpression(expression)) {
       return {
         properties: expression.properties.map((property) => {
-          if (isPropertyAssignment$1(property) && (isStringLiteral$7(property.name) || isIdentifier$8(property.name))) {
-            if (isIdentifier$8(property.initializer))
+          if (isPropertyAssignment$1(property) && (isStringLiteral$8(property.name) || isIdentifier$9(property.name))) {
+            if (isIdentifier$9(property.initializer))
               return {
                 name: property.name.text,
                 assignedFrom: this.resolveIdentifier(property.initializer)
@@ -344,7 +362,7 @@ class NameBindingResolver {
       return { root: mkFunctionVariableRoot(expression) };
     } else if (isCallExpression$6(expression)) {
       return { root: mkFunctionCallVariableRoot(expression) };
-    } else if (isStringLiteral$7(expression) || isNumericLiteral(expression) || isToken(expression) && expression.kind === SyntaxKind$5.TrueKeyword || isToken(expression) && expression.kind === SyntaxKind$5.FalseKeyword) {
+    } else if (isStringLiteral$8(expression) || isNumericLiteral(expression) || isToken(expression) && expression.kind === SyntaxKind$5.TrueKeyword || isToken(expression) && expression.kind === SyntaxKind$5.FalseKeyword) {
       return { root: mkLiteralVariableRoot(expression) };
     } else {
       return { root: mkOtherVariableRoot(expression) };
@@ -423,9 +441,9 @@ function flattenVariable(variable, path2 = []) {
   } else
     return { path: path2, root: variable.root };
 }
-const { isIdentifier: isIdentifier$7, isPropertyAccessExpression: isPropertyAccessExpression$4 } = c;
+const { isIdentifier: isIdentifier$8, isPropertyAccessExpression: isPropertyAccessExpression$4 } = c;
 function isIdentifierOrPropertyAccessExpression(node) {
-  return isIdentifier$7(node) || isPropertyAccessExpression$4(node);
+  return isIdentifier$8(node) || isPropertyAccessExpression$4(node);
 }
 function byAnd() {
   return (agg, value) => agg && value;
@@ -433,7 +451,7 @@ function byAnd() {
 const {
   isCallExpression: isCallExpression$5,
   isExpressionStatement: isExpressionStatement$1,
-  isIdentifier: isIdentifier$6,
+  isIdentifier: isIdentifier$7,
   isPropertyAccessExpression: isPropertyAccessExpression$3,
   isBlock: isBlock$3
 } = c;
@@ -455,7 +473,7 @@ function findEventHandlersBlock(functionDeclaration, bindingResolver) {
                 eventHandlerCallStatement: statement,
                 handlerIndex: nextEventHandlerIndex++
               });
-            else if (isIdentifier$6(handler) || isPropertyAccessExpression$3(handler)) {
+            else if (isIdentifier$7(handler) || isPropertyAccessExpression$3(handler)) {
               let flattenedHandler = flattenVariable(
                 bindingResolver.explain(handler)
               );
@@ -476,10 +494,10 @@ function findEventHandlersBlock(functionDeclaration, bindingResolver) {
   return foundEventHandlers;
 }
 const {
-  isIdentifier: isIdentifier$5,
+  isIdentifier: isIdentifier$6,
   SyntaxKind: SyntaxKind$4,
-  isStringLiteral: isStringLiteral$6,
-  visitNode: visitNode$3,
+  isStringLiteral: isStringLiteral$7,
+  visitNode: visitNode$4,
   isFunctionDeclaration: isFunctionDeclaration$1,
   isVariableStatement: isVariableStatement$2,
   isImportDeclaration: isImportDeclaration$3,
@@ -582,7 +600,7 @@ class SourceFileBindingResolver {
       nbResolversQueue.unshift(new NameBindingResolver(nbResolversQueue[0]));
       this.nameBindingResolvers.set(node, nbResolversQueue[0]);
       callback();
-      node.getChildren().forEach((child) => visitNode$3(child, visitor));
+      node.getChildren().forEach((child) => visitNode$4(child, visitor));
       nbResolversQueue.shift();
       return node;
     };
@@ -608,7 +626,7 @@ class SourceFileBindingResolver {
             node.initializer
           )
         );
-      } else if ((isForInStatement$1(node) || isForOfStatement$1(node)) && isVariableDeclarationList(node.initializer) && node.initializer.declarations.length === 1 && isIdentifier$5(node.initializer.declarations[0].name)) {
+      } else if ((isForInStatement$1(node) || isForOfStatement$1(node)) && isVariableDeclarationList(node.initializer) && node.initializer.declarations.length === 1 && isIdentifier$6(node.initializer.declarations[0].name)) {
         return doWithChildBindingResolver(node, () => {
           let name = node.initializer.declarations[0].name.text;
           nbResolversQueue[0].addVariable(
@@ -621,10 +639,10 @@ class SourceFileBindingResolver {
           );
         });
       }
-      node.getChildren().forEach((child) => visitNode$3(child, visitor));
+      node.getChildren().forEach((child) => visitNode$4(child, visitor));
       return node;
     };
-    visitNode$3(sourceFile, visitor);
+    visitNode$4(sourceFile, visitor);
   }
   findBindingResolver(node) {
     let found;
@@ -637,7 +655,7 @@ class SourceFileBindingResolver {
   }
   explainFlattenedVariableType(flattened) {
     if (!!flattened.root) {
-      if (isImportModuleVariableRoot(flattened.root) && isStringLiteral$6(flattened.root.module)) {
+      if (isImportModuleVariableRoot(flattened.root) && isStringLiteral$7(flattened.root.module)) {
         return new ImportFromModuleResolvedType(flattened.root.module.text, flattened.path);
       }
     } else
@@ -647,7 +665,7 @@ class SourceFileBindingResolver {
     if (type) {
       if (isTypeReferenceNode$1(type)) {
         let typeName = type.typeName;
-        if (isIdentifier$5(typeName)) {
+        if (isIdentifier$6(typeName)) {
           let resolved = this.findBindingResolver(typeName).resolveIdentifier(typeName);
           let flattened = flattenVariable(resolved);
           let typeFromFlattened = this.explainFlattenedVariableType(flattened);
@@ -689,7 +707,7 @@ const {
   isFunctionDeclaration,
   isDecorator,
   isCallExpression: isCallExpression$4,
-  isIdentifier: isIdentifier$4,
+  isIdentifier: isIdentifier$5,
   isPropertyAccessExpression: isPropertyAccessExpression$2,
   isReturnStatement,
   isNewExpression: isNewExpression$1,
@@ -762,7 +780,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
       if (isFunctionDeclaration(node)) {
         let declaredTargetEnv = 0;
         node.modifiers && node.modifiers.forEach((modifier) => {
-          if (isDecorator(modifier) && isCallExpression$4(modifier.expression) && isIdentifier$4(modifier.expression.expression) && modifier.expression.expression.text === "JayPattern" && modifier.expression.arguments.length === 1 && isPropertyAccessExpression$2(modifier.expression.arguments[0]) && isIdentifier$4(modifier.expression.arguments[0].expression) && modifier.expression.arguments[0].expression.text === "JayTargetEnv" && modifier.expression.arguments[0].name.text === "any")
+          if (isDecorator(modifier) && isCallExpression$4(modifier.expression) && isIdentifier$5(modifier.expression.expression) && modifier.expression.expression.text === "JayPattern" && modifier.expression.arguments.length === 1 && isPropertyAccessExpression$2(modifier.expression.arguments[0]) && isIdentifier$5(modifier.expression.arguments[0].expression) && modifier.expression.arguments[0].expression.text === "JayTargetEnv" && modifier.expression.arguments[0].name.text === "any")
             declaredTargetEnv = 1;
         });
         let name = node.name.text;
@@ -799,7 +817,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
               sourceFileBinding,
               node
             );
-          } else if (isExpressionStatement(statement) && isBinaryExpression$1(statement.expression) && isPropertyAccessExpression$2(statement.expression.left) && statement.expression.operatorToken.kind === SyntaxKind$3.EqualsToken && isIdentifier$4(statement.expression.right)) {
+          } else if (isExpressionStatement(statement) && isBinaryExpression$1(statement.expression) && isPropertyAccessExpression$2(statement.expression.left) && statement.expression.operatorToken.kind === SyntaxKind$3.EqualsToken && isIdentifier$5(statement.expression.right)) {
             patternType = 3;
             leftHandSide = statement.expression.left;
             callArgumentTypes = [
@@ -851,7 +869,7 @@ function compileFunctionSplitPatternsBlock(patternFiles) {
   });
   return new WithValidations(compiledPatterns, validations);
 }
-const { visitEachChild: visitEachChild$3, transform: transform$4, visitNode: visitNode$2 } = c;
+const { visitEachChild: visitEachChild$3, transform: transform$4, visitNode: visitNode$3 } = c;
 function visitWithContext(node, initialContext, contextualVisitor) {
   return visitWithContext2(node, initialContext, void 0, contextualVisitor);
 }
@@ -860,7 +878,7 @@ function visitWithContext2(node, initialContext, transformationContext, contextu
   const visitChild = (node2, childContext) => {
     if (childContext)
       contexts.push(childContext);
-    let visitedNode = visitNode$2(node2, visitor);
+    let visitedNode = visitNode$3(node2, visitor);
     if (childContext)
       contexts.pop();
     return visitedNode;
@@ -876,7 +894,7 @@ function visitWithContext2(node, initialContext, transformationContext, contextu
   const visitor = (node2) => {
     return contextualVisitor(node2, contexts.at(-1), visitChild, _visitEachChild);
   };
-  return visitNode$2(node, visitor);
+  return visitNode$3(node, visitor);
 }
 const { isTypeReferenceNode } = c;
 function isFirstParamJayEvent(eventHandler, bindingResolver) {
@@ -895,14 +913,14 @@ function filterEventHandlersToHaveJayEventType(foundEventHandlers, bindingResolv
 }
 const {
   visitEachChild: visitEachChild$2,
-  isIdentifier: isIdentifier$3,
+  isIdentifier: isIdentifier$4,
   SyntaxKind: SyntaxKind$2,
   transform: transform$3,
-  isStatement: isStatement$1,
+  isStatement: isStatement$2,
   isBlock: isBlock$1,
   isExpression: isExpression$1,
   isLiteralExpression: isLiteralExpression$1,
-  visitNode: visitNode$1
+  visitNode: visitNode$2
 } = c;
 function generateFunctionRepository(matchedReturnPatterns, matchedVariableReads, matchedConstants, safeStatements) {
   const constCode = [...new Set(matchedConstants)].join("\n");
@@ -947,7 +965,7 @@ const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolv
     return patternIndexes.get(pattern);
   };
   const visitor = (node, { parentStatementTargetEnv }, visitChild, visitEachChild2) => {
-    if (isStatement$1(node)) {
+    if (isStatement$2(node)) {
       let statementAnalysis = analyzer.getStatementStatus(node);
       if (statementAnalysis)
         parentStatementTargetEnv = intersectJayTargetEnv(
@@ -987,9 +1005,9 @@ const mkTransformEventHandlerStatementVisitor = (factory, context, bindingResolv
         let patternKey = getPatternIndex(pattern);
         if (pattern.patternType === CompilePatternType.RETURN)
           sideEffects.matchedReturnPatterns.push({ pattern, patternKey });
-        else if (pattern.patternType === CompilePatternType.KNOWN_VARIABLE_READ && isIdentifier$3(node))
+        else if (pattern.patternType === CompilePatternType.KNOWN_VARIABLE_READ && isIdentifier$4(node))
           sideEffects.matchedVariableReads.push({ variable: node, patternKey });
-        else if (pattern.patternType === CompilePatternType.CONST_READ && isIdentifier$3(node)) {
+        else if (pattern.patternType === CompilePatternType.CONST_READ && isIdentifier$4(node)) {
           let constant = bindingResolver.explain(node);
           let flattenedConstant = flattenVariable(constant);
           let literal = flattenedConstant.root.literal;
@@ -1048,7 +1066,7 @@ const analyzeEventHandlerByPatternBlock = (context, bindingResolver, analyzer, f
         let mainNode = isBlock$1(node) && sideEffects.mainContextBlocks.has(node) ? sideEffects.mainContextBlocks.get(node) : node;
         return visitEachChild$2(mainNode, replaceBodiesVisitor, context);
       };
-      bodyForFunctionRepository = visitNode$1(body, replaceBodiesVisitor);
+      bodyForFunctionRepository = visitNode$2(body, replaceBodiesVisitor);
     }
     const { handlerCode, key } = generateFunctionRepository(
       sideEffects.matchedReturnPatterns,
@@ -1141,13 +1159,13 @@ function analyzeEventHandlers(context, bindingResolver, analyzer, factory, found
 const {
   isBinaryExpression,
   isCallExpression: isCallExpression$2,
-  isIdentifier: isIdentifier$2,
+  isIdentifier: isIdentifier$3,
   isNewExpression,
   isPropertyAccessExpression,
   SyntaxKind: SyntaxKind$1,
   isArrowFunction: isArrowFunction$1,
   isLiteralExpression,
-  isStatement,
+  isStatement: isStatement$1,
   isVariableStatement: isVariableStatement$1,
   isBlock,
   isIfStatement,
@@ -1309,7 +1327,7 @@ class ScopedSourceFileStatementAnalyzer {
         /* none */
       },
       (node, { statement, roleInParent }, visitChild) => {
-        if (isStatement(node))
+        if (isStatement$1(node))
           statement = node;
         if (roleInParent === 1 || roleInParent === 2) {
           if (isIdentifierOrPropertyAccessExpression(node))
@@ -1569,7 +1587,7 @@ function isChildOf(node, parent) {
       return true;
   return isChildOf(node.parent, parent);
 }
-const { isCallExpression: isCallExpression$1, isIdentifier: isIdentifier$1, isStringLiteral: isStringLiteral$5, isVariableStatement, forEachChild: forEachChild$1 } = c;
+const { isCallExpression: isCallExpression$1, isIdentifier: isIdentifier$2, isStringLiteral: isStringLiteral$6, isVariableStatement, forEachChild: forEachChild$1 } = c;
 var FindComponentConstructorType = /* @__PURE__ */ ((FindComponentConstructorType2) => {
   FindComponentConstructorType2["makeJayComponent"] = "makeJayComponent";
   FindComponentConstructorType2["makeJayTsxComponent"] = "makeJayTsxComponent";
@@ -1584,7 +1602,7 @@ function findComponentConstructorCalls(findType, bindingResolver, node) {
           declaration.initializer.expression
         );
         const flattened = flattenVariable(explainedInitializer);
-        if (flattened.path.length === 1 && flattened.path[0] === findType && flattened.root && isImportModuleVariableRoot(flattened.root) && isStringLiteral$5(flattened.root.module) && flattened.root.module.text === JAY_COMPONENT) {
+        if (flattened.path.length === 1 && flattened.path[0] === findType && flattened.root && isImportModuleVariableRoot(flattened.root) && isStringLiteral$6(flattened.root.module) && flattened.root.module.text === JAY_COMPONENT) {
           let render = findType === "makeJayComponent" ? declaration.initializer.arguments[0] : void 0;
           let comp = findType === "makeJayComponent" ? declaration.initializer.arguments[1] : declaration.initializer.arguments[0];
           let foundConstructor = {
@@ -1666,14 +1684,14 @@ export ${_}`
     );
   }
 }
-const { isCallExpression, isIdentifier, isStringLiteral: isStringLiteral$4, forEachChild } = c;
+const { isCallExpression, isIdentifier: isIdentifier$1, isStringLiteral: isStringLiteral$5, forEachChild } = c;
 function findExec$(bindingResolver, sourceFile) {
   const foundExec$ = [];
   function visit(node) {
-    if (isCallExpression(node) && isIdentifier(node.expression)) {
+    if (isCallExpression(node) && isIdentifier$1(node.expression)) {
       const functionVariable = bindingResolver.explain(node.expression);
       const accessChain = flattenVariable(functionVariable);
-      if (accessChain.path.length === 1 && accessChain.path[0] === "exec$" && isImportModuleVariableRoot(accessChain.root) && isStringLiteral$4(accessChain.root.module) && accessChain.root.module.text === "@jay-framework/secure")
+      if (accessChain.path.length === 1 && accessChain.path[0] === "exec$" && isImportModuleVariableRoot(accessChain.root) && isStringLiteral$5(accessChain.root.module) && accessChain.root.module.text === "@jay-framework/secure")
         foundExec$.push(node);
     }
     forEachChild(node, visit);
@@ -1681,7 +1699,7 @@ function findExec$(bindingResolver, sourceFile) {
   forEachChild(sourceFile, visit);
   return foundExec$;
 }
-const { transform: transform$2, isArrowFunction, isExpression, visitNode } = c;
+const { transform: transform$2, isArrowFunction, isExpression, visitNode: visitNode$1 } = c;
 function analyzeGlobalExec$(context, analyzer, functionRepositoryBuilder, foundExec$) {
   const scopedAnalyzer = analyzer.analyzeForScope(foundExec$);
   let foundUnsafeExpression = false;
@@ -1690,12 +1708,12 @@ function analyzeGlobalExec$(context, analyzer, functionRepositoryBuilder, foundE
       const matchedPattern = scopedAnalyzer.getExpressionStatus(node);
       foundUnsafeExpression = foundUnsafeExpression || !matchedPattern || !matchedPattern.subExpressionsMatching;
     } else {
-      node.getChildren().forEach((child) => visitNode(child, visitor));
+      node.getChildren().forEach((child) => visitNode$1(child, visitor));
     }
     return node;
   };
   if (isArrowFunction(foundExec$.arguments[0]))
-    visitNode(foundExec$.arguments[0].body, visitor);
+    visitNode$1(foundExec$.arguments[0].body, visitor);
   if (foundUnsafeExpression)
     return { foundExec$, wasTransformed: false };
   else {
@@ -1718,7 +1736,7 @@ function transformedGlobalExec$toReplaceMap(transformedGlobalExec$s) {
   });
   return map;
 }
-const { SyntaxKind, transform: transform$1, isStringLiteral: isStringLiteral$3, isInterfaceDeclaration, isImportDeclaration: isImportDeclaration$2 } = c;
+const { SyntaxKind, transform: transform$1, isStringLiteral: isStringLiteral$4, isInterfaceDeclaration, isImportDeclaration: isImportDeclaration$2 } = c;
 function generateComponentConstructorCalls(context, componentConstructorCalls, hasFunctionRepository) {
   let optionsParam = hasFunctionRepository ? ", { funcRepository }" : "";
   let transformedConstructors = componentConstructorCalls.map(({ name, render }) => {
@@ -1741,7 +1759,7 @@ function getRenderImportSpecifier(node) {
   }
 }
 function transformImport(node, importerMode, context, hasFunctionRepository) {
-  if (isStringLiteral$3(node.moduleSpecifier)) {
+  if (isStringLiteral$4(node.moduleSpecifier)) {
     if (findMakeJayComponentImport(MAKE_JAY_COMPONENT, node)) {
       const code = hasFunctionRepository ? `import { makeJayComponentBridge, FunctionsRepository } from '@jay-framework/secure';` : `import { makeJayComponentBridge } from '@jay-framework/secure';`;
       return codeToAst(code, context)[0];
@@ -1839,9 +1857,9 @@ function transformComponentBridge(importerMode, patterns = [], globalFunctionRep
     globalFunctionRepository
   });
 }
-const { isStringLiteral: isStringLiteral$2 } = c;
+const { isStringLiteral: isStringLiteral$3 } = c;
 function transformImportModeFileExtension(node, factory, importerMode) {
-  if (!isStringLiteral$2(node.moduleSpecifier))
+  if (!isStringLiteral$3(node.moduleSpecifier))
     return void 0;
   const originalTarget = node.moduleSpecifier.text;
   if (!isRelativeImport(originalTarget))
@@ -1882,9 +1900,9 @@ function transformComponentImports(needsHandler$, needsFunc$, needsFuncGlobal$,
   } else
     return transformedSourceFile;
 }
-const { visitEachChild, transform, isStringLiteral: isStringLiteral$1, isImportDeclaration } = c;
+const { visitEachChild, transform, isStringLiteral: isStringLiteral$2, isImportDeclaration } = c;
 function isCssImport(node) {
-  return isStringLiteral$1(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith(".css");
+  return isStringLiteral$2(node.moduleSpecifier) && node.moduleSpecifier.text.endsWith(".css");
 }
 function mkComponentTransformer(sftContext) {
   const { patterns, globalFunctionRepository, context, factory, sourceFile } = sftContext;
@@ -1974,10 +1992,10 @@ function generateImportsFileFromJayFile(jayFile) {
 function fromImportModules(modules) {
   return modules.filter(isRelativeImport).map((module) => `import '${module}${JAY_QUERY_WORKER_TRUSTED}'`).join("\n");
 }
-const { isStringLiteral } = c;
+const { isStringLiteral: isStringLiteral$1 } = c;
 function parseImportLinks(sourceFile) {
   const importDeclarations = extractImportDeclarations(sourceFile).filter(
-    (importDeclaration) => isStringLiteral(importDeclaration.moduleSpecifier)
+    (importDeclaration) => isStringLiteral$1(importDeclaration.moduleSpecifier)
   );
   const importLinks = importDeclarations.map((importDeclaration) => {
     const module = importDeclaration.moduleSpecifier.text;
@@ -2016,24 +2034,140 @@ function parseGenericTypescriptFile(filePath, code) {
     []
   );
 }
+const { isIdentifier, isStatement, visitNode } = c;
+class SourceFileStatementDependencies {
+  constructor(sourceFile, bindingResolver) {
+    __publicField(this, "statementDependencies", /* @__PURE__ */ new Map());
+    let parents = [];
+    let id = 0;
+    const visitor = (node) => {
+      if (isStatement(node)) {
+        const statementDependencies = {
+          statement: node,
+          parent: parents.at(-1)?.statement,
+          isDependencyFor: /* @__PURE__ */ new Set(),
+          dependsOn: /* @__PURE__ */ new Set(),
+          id: id++
+        };
+        this.statementDependencies.set(node, statementDependencies);
+        parents.push(statementDependencies);
+      }
+      if (isIdentifier(node)) {
+        let variable = bindingResolver.explain(node);
+        let thisStatementDependencies = parents.at(-1);
+        if (variable.definingStatement && variable.definingStatement !== thisStatementDependencies.statement) {
+          let dependsOnStatementDependencies = this.statementDependencies.get(
+            variable.definingStatement
+          );
+          thisStatementDependencies.dependsOn.add(dependsOnStatementDependencies);
+          dependsOnStatementDependencies.isDependencyFor.add(thisStatementDependencies);
+        }
+      }
+      node.getChildren().forEach((child) => visitNode(child, visitor));
+      if (isStatement(node))
+        parents.pop();
+      return node;
+    };
+    visitNode(sourceFile, visitor);
+  }
+  getDependsOn(statement) {
+    return this.statementDependencies.get(statement).dependsOn;
+  }
+  getIsDependencyFor(statement) {
+    return this.statementDependencies.get(statement).isDependencyFor;
+  }
+  getAllStatements() {
+    return this.statementDependencies.values();
+  }
+  getStatementDependencies(statement) {
+    return this.statementDependencies.get(statement);
+  }
+}
+const { isStringLiteral } = c;
+function areFlattenedAccessChainsEqual(chain1, chain2) {
+  if (chain1.path.length !== chain2.path.length) {
+    return false;
+  }
+  const pathsEqual = chain1.path.every((value, index) => value === chain2.path[index]);
+  if (!pathsEqual) {
+    return false;
+  }
+  return areVariableRootsEqual(chain1.root, chain2.root);
+}
+function areVariableRootsEqual(root1, root2) {
+  if (!root1 && !root2) {
+    return true;
+  }
+  if (!root1 || !root2) {
+    return false;
+  }
+  if (root1.kind !== root2.kind) {
+    return false;
+  }
+  switch (root1.kind) {
+    case VariableRootType.ImportModule:
+      if (isImportModuleVariableRoot(root1) && isImportModuleVariableRoot(root2)) {
+        const module1 = isStringLiteral(root1.module) ? root1.module.text : String(root1.module);
+        const module2 = isStringLiteral(root2.module) ? root2.module.text : String(root2.module);
+        return module1 === module2 && root1.importType === root2.importType;
+      }
+      return false;
+    case VariableRootType.FunctionParameter:
+    case VariableRootType.FunctionDefinition:
+    case VariableRootType.Literal:
+    case VariableRootType.FunctionCall:
+      return true;
+    case VariableRootType.Global:
+    case VariableRootType.Other:
+      return true;
+    default:
+      return false;
+  }
+}
 function generateElementFile(jayFile, importerMode, generateTarget = GenerateTarget.jay) {
   return generateTarget === GenerateTarget.jay ? generateElementFile$1(jayFile, importerMode) : generateElementFileReactTarget(jayFile, importerMode);
 }
 export {
   FunctionRepositoryBuilder,
+  ImportType,
+  LetOrConst,
+  NameBindingResolver,
+  SourceFileBindingResolver,
+  SourceFileStatementDependencies,
+  UNKNOWN_VARIABLE,
+  VariableRootType,
+  areFlattenedAccessChainsEqual,
   compileFunctionSplitPatternsBlock,
   createTsSourceFileFromSource,
   extractImportDeclarations,
   extractImportedModules,
+  flattenVariable,
   generateElementDefinitionFile,
   generateElementFile,
   generateImportsFileFromJayFile,
   generateImportsFileFromTsSource,
   getImportName,
   getImportSpecifiers,
+  isFunctionCallVariableRoot,
+  isFunctionVariableRoot,
+  isGlobalVariableRoot,
+  isImportModuleVariableRoot,
+  isLiteralVariableRoot,
+  isOtherVariableRoot,
+  isParamVariableRoot,
   isRelativeImport,
+  mkFunctionCallVariableRoot,
+  mkFunctionVariableRoot,
+  mkGlobalVariableRoot,
+  mkImportModuleVariableRoot,
+  mkLiteralVariableRoot,
+  mkOtherVariableRoot,
+  mkParameterVariableRoot,
+  mkTransformer,
+  mkVariable,
   parseGenericTypescriptFile,
   transformComponent,
   transformComponentBridge,
-  transformComponentImports
+  transformComponentImports,
+  tsBindingNameToVariable
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/compiler",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "",
   "license": "Apache-2.0",
   "main": "dist/index.js",
@@ -25,12 +25,12 @@
   },
   "author": "",
   "dependencies": {
-    "@jay-framework/compiler-analyze-exported-types": "^0.8.0",
-    "@jay-framework/compiler-jay-html": "^0.8.0",
-    "@jay-framework/compiler-shared": "^0.8.0",
-    "@jay-framework/component": "^0.8.0",
-    "@jay-framework/runtime": "^0.8.0",
-    "@jay-framework/secure": "^0.8.0",
+    "@jay-framework/compiler-analyze-exported-types": "^0.9.0",
+    "@jay-framework/compiler-jay-html": "^0.9.0",
+    "@jay-framework/compiler-shared": "^0.9.0",
+    "@jay-framework/component": "^0.9.0",
+    "@jay-framework/runtime": "^0.9.0",
+    "@jay-framework/secure": "^0.9.0",
     "@types/js-yaml": "^4.0.9",
     "change-case": "^4.1.2",
     "js-yaml": "^4.1.0",
@@ -41,7 +41,7 @@
   },
   "devDependencies": {
     "@caiogondim/strip-margin": "^1.0.0",
-    "@jay-framework/dev-environment": "^0.8.0",
+    "@jay-framework/dev-environment": "^0.9.0",
     "@testing-library/jest-dom": "^6.2.0",
     "@types/js-beautify": "^1",
     "@types/node": "^20.11.5",