honeymoose
/
angular-cn
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
angular-cn/goldens/circular-deps/packages.json

1201 lines
44 KiB
JSON
Raw Normal View History

ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
[
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/animations/browser/src/render/animation_driver.ts",
"packages/animations/browser/src/render/shared.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/compiler-cli/ngcc/src/packages/configuration.ts",
"packages/compiler-cli/ngcc/src/packages/entry_point.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/compiler-cli/src/metadata/bundle_index_host.ts",
"packages/compiler-cli/src/transformers/metadata_cache.ts",
"packages/compiler-cli/src/metadata/index.ts"
],
[
"packages/compiler-cli/src/metadata/bundle_index_host.ts",
"packages/compiler-cli/src/transformers/metadata_cache.ts",
"packages/compiler-cli/src/transformers/compiler_host.ts",
"packages/compiler-cli/src/metadata/index.ts"
],
[
"packages/compiler-cli/src/metadata/bundle_index_host.ts",
"packages/compiler-cli/src/transformers/metadata_cache.ts",
"packages/compiler-cli/src/transformers/compiler_host.ts",
"packages/compiler-cli/src/transformers/metadata_reader.ts",
"packages/compiler-cli/src/metadata/index.ts"
],
[
"packages/compiler-cli/src/metadata/collector.ts",
"packages/compiler-cli/src/metadata/evaluator.ts"
],
[
"packages/compiler-cli/src/ngtsc/partial_evaluator/src/interface.ts",
"packages/compiler-cli/src/ngtsc/partial_evaluator/src/interpreter.ts"
],
[
"packages/compiler-cli/src/ngtsc/routing/src/analyzer.ts",
"packages/compiler-cli/src/ngtsc/routing/src/lazy.ts"
],
[
"packages/compiler-cli/src/ngtsc/scope/src/component_scope.ts",
"packages/compiler-cli/src/ngtsc/scope/src/local.ts"
],
[
"packages/compiler-cli/test/helpers/index.ts",
"packages/compiler-cli/test/helpers/src/mock_file_loading.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/lifecycle_reflector.ts",
"packages/compiler/src/compile_reflector.ts",
"packages/compiler/src/output/output_ast.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/ml_parser/parser.ts",
"packages/compiler/src/ml_parser/ast.ts",
"packages/compiler/src/i18n/i18n_ast.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/ml_parser/parser.ts",
"packages/compiler/src/ml_parser/ast.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/ml_parser/parser.ts",
"packages/compiler/src/ml_parser/lexer.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/ml_parser/parser.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/util.ts",
"packages/compiler/src/constant_pool.ts",
"packages/compiler/src/output/output_ast.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/util.ts",
"packages/compiler/src/output/output_ast.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/compile_metadata.ts",
"packages/compiler/src/util.ts",
"packages/compiler/src/parse_util.ts"
],
[
"packages/compiler/src/output/output_ast.ts",
"packages/compiler/src/render3/view/i18n/meta.ts"
],
[
"packages/compiler/src/output/output_ast.ts",
"packages/compiler/src/render3/view/i18n/meta.ts",
"packages/compiler/src/render3/view/i18n/util.ts"
],
[
"packages/compiler/src/render3/r3_factory.ts",
"packages/compiler/src/render3/view/util.ts",
"packages/compiler/src/render3/view/api.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/compiler/src/render3/view/styling_builder.ts",
"packages/compiler/src/render3/view/template.ts"
],
[
"packages/core/src/application_init.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/element_ref.ts",
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/view.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/element_ref.ts",
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/view.ts",
"packages/core/src/metadata.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/element_ref.ts",
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/view.ts",
"packages/core/src/render3/interfaces/container.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/linker/view_ref.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/element_ref.ts",
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/view.ts",
"packages/core/src/render3/interfaces/definition.ts",
"packages/core/src/core.ts",
"packages/core/src/metadata.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/element_ref.ts",
"packages/core/src/render3/state.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/assert.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/ng_module_factory.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/ng_module_factory.ts",
"packages/core/src/linker/component_factory_resolver.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/view_container_ref.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/di.ts",
"packages/core/src/di/injector_compatibility.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/di.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/di.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/instructions/shared.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/instructions/shared.ts",
"packages/core/src/error_handler.ts",
"packages/core/src/errors.ts",
"packages/core/src/view/types.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/instructions/shared.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/instructions/shared.ts",
"packages/core/src/render3/instructions/lview_debug.ts",
"packages/core/src/core.ts",
"packages/core/src/metadata.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector_compatibility.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/view_ref.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
"packages/core/src/change_detection/change_detection.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/change_detection/differs/default_keyvalue_differ.ts",
"packages/core/src/change_detection/differs/keyvalue_differs.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
"packages/core/src/application_tokens.ts",
"packages/core/src/linker/component_factory.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/console.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/linker/compiler.ts",
"packages/core/src/metadata.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/render3/component.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/core.ts",
"packages/core/src/metadata.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/render3/component.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/render3/component.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
"packages/core/src/render3/component.ts",
"packages/core/src/render3/util/global_utils.ts",
"packages/core/src/render3/util/change_detection_utils.ts",
"packages/core/src/render3/util/discovery_utils.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/view/provider.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/view/provider.ts",
"packages/core/src/view/refs.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/view/provider.ts",
"packages/core/src/view/refs.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/view/provider.ts",
"packages/core/src/view/refs.ts",
"packages/core/src/view/ng_module.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/view/provider.ts",
"packages/core/src/view/refs.ts",
"packages/core/src/view/ng_module.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
"packages/core/src/render3/component_ref.ts",
"packages/core/src/view/provider.ts",
"packages/core/src/view/refs.ts",
"packages/core/src/view/ng_module.ts",
"packages/core/src/view/util.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
],
[
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/ng_module_ref.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/ng_module_ref.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/ng_module_ref.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/ng_module_ref.ts",
"packages/core/src/linker/ng_module_factory_registration.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/ng_module_ref.ts",
"packages/core/src/metadata/ng_module.ts"
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
],
[
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/linker/compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/ng_module_ref.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/environment.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/environment.ts",
"packages/core/src/render3/index.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/environment.ts",
"packages/core/src/render3/index.ts",
"packages/core/src/render3/features/providers_feature.ts",
"packages/core/src/render3/di_setup.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/environment.ts",
"packages/core/src/render3/index.ts",
"packages/core/src/render3/features/providers_feature.ts",
"packages/core/src/render3/di_setup.ts",
"packages/core/src/render3/instructions/all.ts",
"packages/core/src/render3/instructions/di.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/environment.ts",
"packages/core/src/render3/index.ts",
"packages/core/src/render3/features/providers_feature.ts",
"packages/core/src/render3/di_setup.ts",
"packages/core/src/render3/instructions/all.ts",
"packages/core/src/render3/instructions/di.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/environment.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/index.ts",
"packages/core/src/render3/pipe.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/application_ref.ts",
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/jit/environment.ts",
"packages/core/src/render3/index.ts",
"packages/core/src/render3/pipe.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/render3/definition.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/ng_module.ts"
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/application_ref.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/module.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/metadata/resource_loading.ts",
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/module.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
"packages/core/src/application_ref.ts",
"packages/core/src/testability/testability.ts",
"packages/core/src/di.ts",
"packages/core/src/di/index.ts",
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts",
"packages/core/src/di/jit/environment.ts",
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts"
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/linker/component_factory.ts"
],
[
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
"packages/core/src/linker/ng_module_factory.ts",
"packages/core/src/linker/component_factory_resolver.ts",
"packages/core/src/linker/component_factory.ts"
],
[
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
"packages/core/src/linker/view_container_ref.ts",
"packages/core/src/linker/component_factory.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/change_detection/change_detection.ts",
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
"packages/core/src/render3/instructions/shared.ts",
"packages/core/src/error_handler.ts",
"packages/core/src/errors.ts",
"packages/core/src/view/types.ts",
"packages/core/src/linker/component_factory.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/linker/element_ref.ts",
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/view.ts",
"packages/core/src/render3/interfaces/container.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/linker/view_ref.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/change_detection/change_detector_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/view_ref.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/change_detection/differs/default_iterable_differ.ts",
"packages/core/src/change_detection/differs/iterable_differs.ts"
],
[
"packages/core/src/change_detection/differs/default_keyvalue_differ.ts",
"packages/core/src/change_detection/differs/keyvalue_differs.ts"
],
refactor(core): Remove reliance on `TNodeType.View`. (#38707) `TNodeType.View` was created to support inline views. That feature did not materialize and we have since removed the instructions for it, leave an unneeded `TNodeType.View` which was still used in a very inconsistent way. This change no longer created `TNodeType.View` (and there will be a follow up chang to completely remove it.) Also simplified the mental model so that `LView[HOST]`/`LView[T_HOST]` always point to the insertion location of the `LView`. PR Close #38707
2020-09-14 14:21:15 -04:00
[
"packages/core/src/debug/debug_node.ts",
"packages/core/src/view/index.ts",
"packages/core/src/view/entrypoint.ts",
"packages/core/src/view/services.ts"
],
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
[
"packages/core/src/di/injectable.ts",
"packages/core/src/di/jit/injectable.ts"
],
[
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector_compatibility.ts",
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/di/injector.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/r3_injector.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
"packages/core/src/di/injector_compatibility.ts",
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/core/src/render3/definition.ts",
"packages/core/src/metadata/ng_module.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/util.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/injector.ts",
"packages/core/src/di/r3_injector.ts"
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/di/reflective_errors.ts",
"packages/core/src/di/reflective_injector.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/error_handler.ts",
"packages/core/src/errors.ts",
"packages/core/src/view/types.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/linker/component_factory_resolver.ts",
"packages/core/src/linker/ng_module_factory.ts"
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/linker/element_ref.ts",
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/renderer.ts",
"packages/core/src/render/api.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/view_engine_compatibility.ts"
refactor(core): use more narrow `QueryList` import to avoid circular deps issue (#36286) Prior to this commit, the `packages/core/src/render3/interfaces/query.ts` file used to import `QueryList` using `../../linker`, which contains a lot of re-exports and as a result, this one import caused a lot of circular deps cycles reported by the tool that checks such deps. In other places in the code the `QueryList` is imported using more narrow import (`linker/query_list`), so this commit uses the same pattern. This change allowed to reduce the number of known cycles from 343 to 207, the golden file was updated accordingly. PR Close #36286
2020-03-27 20:39:14 -04:00
],
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/linker/ng_module_factory_registration.ts",
"packages/core/src/render3/ng_module_ref.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/linker/template_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/linker/view_container_ref.ts",
"packages/core/src/render3/view_engine_compatibility.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts"
],
[
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/directive.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/metadata/resource_loading.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/core/src/metadata/directives.ts",
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/render3/jit/directive.ts",
"packages/core/src/render3/jit/module.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): reduce the number of circular deps (#38805) This commit updates several import statements in the core package to decrease the number of cycles detected by the dependency checker tool. PR Close #38805
2020-09-10 15:38:49 -04:00
"packages/core/src/metadata/directives.ts",
"packages/core/src/render3/jit/pipe.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): Cleanup circular dependency between ViewEngine and Ivy `ElementRef`. (#39621) `ElementRef` is declared in ViewEngine but it sub-classed in Ivy. This creates a circular dependency between ViewEngine `ElementRef` which needs to declare `__NG_ELEMENT_ID__` and ivy factory which needs to create it. The workaround used to be to pass the `ElementRef` through stack but that created a very convoluted code. This refactoring simply bundles the two files together and removes the stack workaround making the code simpler to follow. PR Close #39621
2020-11-09 20:09:49 -05:00
"packages/core/src/render3/interfaces/container.ts",
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/view.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/interfaces/container.ts",
"packages/core/src/render3/interfaces/view.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/interfaces/definition.ts",
refactor(core): add debug ranges to `LViewDebug` with matchers (#38359) This change provides better typing for the `LView.debug` property which is intended to be used by humans while debugging the application with `ngDevMode` turned on. In addition this chang also adds jasmine matchers for better asserting that `LView` is in the correct state. PR Close #38359
2020-08-05 22:16:20 -04:00
"packages/core/src/render3/interfaces/node.ts",
"packages/core/src/render3/interfaces/view.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/interfaces/definition.ts",
"packages/core/src/render3/interfaces/view.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): clean up circular dependencies (#39233) Moved code from `interfaces/i18n.ts` which was causing circular dependencies PR Close #39233
2020-10-17 15:20:12 -04:00
"packages/core/src/render3/interfaces/node.ts",
refactor(core): add debug ranges to `LViewDebug` with matchers (#38359) This change provides better typing for the `LView.debug` property which is intended to be used by humans while debugging the application with `ngDevMode` turned on. In addition this chang also adds jasmine matchers for better asserting that `LView` is in the correct state. PR Close #38359
2020-08-05 22:16:20 -04:00
"packages/core/src/render3/interfaces/view.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
refactor(core): clean up circular dependencies (#39233) Moved code from `interfaces/i18n.ts` which was causing circular dependencies PR Close #39233
2020-10-17 15:20:12 -04:00
"packages/core/src/render3/interfaces/node.ts",
fix(core): Store ICU state in `LView` rather than in `TView` (#39233) Before this refactoring/fix the ICU would store the current selected index in `TView`. This is incorrect, since if ICU is in `ngFor` it will cause issues in some circumstances. This refactoring properly moves the state to `LView`. closes #37021 closes #38144 closes #38073 PR Close #39233
2020-09-25 18:01:56 -04:00
"packages/core/src/render3/interfaces/view.ts",
refactor(core): clean up circular dependencies (#39233) Moved code from `interfaces/i18n.ts` which was causing circular dependencies PR Close #39233
2020-10-17 15:20:12 -04:00
"packages/core/src/render3/interfaces/query.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/src/render3/interfaces/query.ts",
"packages/core/src/render3/interfaces/view.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: fix circular deps failure (#36629) With the large scale refactoring of the repo to the new version of clang-format, some import orders were changed. Specifically the imports found in this range. The file previously read: import {TestBed} from './test_bed'; import {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestBedStatic, TestComponentRenderer, TestModuleMetadata} from './test_bed_common'; import {R3TestBedCompiler} from './r3_test_bed_compiler'; and now reads: import {R3TestBedCompiler} from './r3_test_bed_compiler'; import {TestBed} from './test_bed'; import {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestBedStatic, TestComponentRenderer, TestModuleMetadata} from './test_bed_common'; This change in order cause the circular dependency to be entered earlier and changed the golden file for our circular deps discovery. PR Close #36629
2020-04-14 16:17:43 -04:00
"packages/core/testing/src/r3_test_bed_compiler.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/testing/src/test_bed_common.ts",
build: fix circular deps failure (#36629) With the large scale refactoring of the repo to the new version of clang-format, some import orders were changed. Specifically the imports found in this range. The file previously read: import {TestBed} from './test_bed'; import {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestBedStatic, TestComponentRenderer, TestModuleMetadata} from './test_bed_common'; import {R3TestBedCompiler} from './r3_test_bed_compiler'; and now reads: import {R3TestBedCompiler} from './r3_test_bed_compiler'; import {TestBed} from './test_bed'; import {ComponentFixtureAutoDetect, ComponentFixtureNoNgZone, TestBedStatic, TestComponentRenderer, TestModuleMetadata} from './test_bed_common'; This change in order cause the circular dependency to be entered earlier and changed the golden file for our circular deps discovery. PR Close #36629
2020-04-14 16:17:43 -04:00
"packages/core/testing/src/test_bed.ts",
"packages/core/testing/src/r3_test_bed.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/core/testing/src/r3_test_bed.ts",
"packages/core/testing/src/test_bed.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/abstract_control_directive.ts",
"packages/forms/src/model.ts",
refactor(forms): move common validators-related logic to the `AbstractControlDirective` class (#38280) This commit refactors validators-related logic that is common across most of the directives. A couple notes on this refactoring: * common logic was moved to the `AbstractControlDirective` class (including `validator` and `asyncValidator` getters) * sync/async validators are now composed in `AbstractControlDirective` class eagerly when validators are set with `_setValidators` and `_setAsyncValidators` calls and the result is stored in directive instance (thus getters return cached versions of validator fn). This is needed to make sure composed validator function remains the same (retains its identity) for a given directive instance, so that this function can be added and later removed from an instance of an AbstractControl-based class (like `FormControl`). Preserving validator function is required to perform proper cleanup (in followup PRs) of the AbstractControl-based classes when a directive is destroyed. PR Close #38280
2020-07-27 22:31:40 -04:00
"packages/forms/src/directives/shared.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/abstract_control_directive.ts",
"packages/forms/src/model.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/forms/src/directives/shared.ts",
"packages/forms/src/directives/abstract_form_group_directive.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/control_container.ts"
refactor(forms): move common validators-related logic to the `AbstractControlDirective` class (#38280) This commit refactors validators-related logic that is common across most of the directives. A couple notes on this refactoring: * common logic was moved to the `AbstractControlDirective` class (including `validator` and `asyncValidator` getters) * sync/async validators are now composed in `AbstractControlDirective` class eagerly when validators are set with `_setValidators` and `_setAsyncValidators` calls and the result is stored in directive instance (thus getters return cached versions of validator fn). This is needed to make sure composed validator function remains the same (retains its identity) for a given directive instance, so that this function can be added and later removed from an instance of an AbstractControl-based class (like `FormControl`). Preserving validator function is required to perform proper cleanup (in followup PRs) of the AbstractControl-based classes when a directive is destroyed. PR Close #38280
2020-07-27 22:31:40 -04:00
],
[
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/abstract_control_directive.ts",
"packages/forms/src/model.ts",
refactor(forms): move common validators-related logic to the `AbstractControlDirective` class (#38280) This commit refactors validators-related logic that is common across most of the directives. A couple notes on this refactoring: * common logic was moved to the `AbstractControlDirective` class (including `validator` and `asyncValidator` getters) * sync/async validators are now composed in `AbstractControlDirective` class eagerly when validators are set with `_setValidators` and `_setAsyncValidators` calls and the result is stored in directive instance (thus getters return cached versions of validator fn). This is needed to make sure composed validator function remains the same (retains its identity) for a given directive instance, so that this function can be added and later removed from an instance of an AbstractControl-based class (like `FormControl`). Preserving validator function is required to perform proper cleanup (in followup PRs) of the AbstractControl-based classes when a directive is destroyed. PR Close #38280
2020-07-27 22:31:40 -04:00
"packages/forms/src/directives/shared.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/abstract_form_group_directive.ts",
"packages/forms/src/directives/control_container.ts",
"packages/forms/src/directives/form_interface.ts",
"packages/forms/src/directives/ng_control.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/forms/src/directives/abstract_form_group_directive.ts",
"packages/forms/src/directives/control_container.ts",
"packages/forms/src/directives/form_interface.ts"
],
[
"packages/forms/src/directives/abstract_form_group_directive.ts",
"packages/forms/src/directives/control_container.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/form_interface.ts",
"packages/forms/src/model.ts",
"packages/forms/src/directives/shared.ts"
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
],
[
"packages/forms/src/directives/abstract_form_group_directive.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/shared.ts"
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
],
[
"packages/forms/src/directives/abstract_form_group_directive.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/model.ts",
"packages/forms/src/directives/shared.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/forms/src/directives/control_container.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/form_interface.ts",
"packages/forms/src/directives/ng_control.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/ng_form.ts",
"packages/forms/src/directives/ng_model.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/ng_form.ts",
"packages/forms/src/directives/ng_model.ts",
"packages/forms/src/directives/ng_model_group.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_control_directive.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/forms/src/directives/shared.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_group_name.ts",
"packages/forms/src/directives/reactive_directives/form_group_directive.ts",
"packages/forms/src/directives/reactive_directives/form_control_name.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
[
"packages/forms/src/directives/reactive_directives/form_control_directive.ts",
"packages/forms/src/model.ts",
"packages/forms/src/directives/shared.ts",
"packages/forms/src/directives/reactive_directives/form_group_name.ts",
"packages/forms/src/directives/reactive_directives/form_group_directive.ts",
"packages/forms/src/directives/reactive_directives/form_control_name.ts"
],
[
"packages/forms/src/directives/reactive_directives/form_control_name.ts",
"packages/forms/src/directives/reactive_directives/form_group_directive.ts"
],
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_control_name.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/reactive_directives/form_group_name.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_group_directive.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_control_name.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/shared.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/forms/src/directives/reactive_directives/form_group_name.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_group_directive.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_control_name.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/model.ts",
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/forms/src/directives/shared.ts",
"packages/forms/src/directives/reactive_directives/form_group_name.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_group_directive.ts"
],
[
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
"packages/forms/src/directives/reactive_directives/form_group_directive.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/reactive_directives/form_group_name.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
"packages/forms/src/directives/reactive_directives/form_group_directive.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/shared.ts",
"packages/forms/src/directives/reactive_directives/form_group_name.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
[
"packages/forms/src/directives/reactive_directives/form_group_directive.ts",
"packages/forms/src/model.ts",
"packages/forms/src/directives/shared.ts",
"packages/forms/src/directives/reactive_directives/form_group_name.ts"
],
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
[
"packages/forms/src/directives/reactive_directives/form_group_name.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/shared.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/reactive_directives/form_group_name.ts",
"packages/forms/src/model.ts",
"packages/forms/src/directives/shared.ts"
],
[
"packages/forms/src/directives/shared.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/model.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/shared.ts",
"packages/forms/src/validators.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/directives/validators.ts",
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/model.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
[
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
"packages/forms/src/directives/shared.ts",
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/forms/src/validators.ts",
"packages/forms/src/model.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
],
fix(forms): more precise control cleanup (#39623) Currently when an instance of the `FormControlName` directive is destroyed, the Forms package invokes the `cleanUpControl` to clear all directive-specific logic (such as validators, onChange handlers, etc) from a bound control. The logic of the `cleanUpControl` function should revert all setup performed by the `setUpControl` function. However the `cleanUpControl` is too aggressive and removes all callbacks related to the onChange and disabled state handling. This is causing problems when a form control is bound to multiple FormControlName` directives, causing other instances of that directive to stop working correctly when the first one is destroyed. This commit updates the cleanup logic to only remove callbacks added while setting up a control for a given directive instance. The fix is needed to allow adding `cleanUpControl` function to other places where cleanup is needed (missing this function calls in some other places causes memory leak issues). PR Close #39623
2020-11-10 01:58:19 -05:00
[
"packages/forms/src/directives/validators.ts",
"packages/forms/src/validators.ts"
],
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
[
"packages/language-service/src/completions.ts",
"packages/language-service/src/template.ts",
"packages/language-service/src/typescript_host.ts",
"packages/language-service/src/language_service.ts"
],
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
[
"packages/language-service/src/template.ts",
"packages/language-service/src/typescript_host.ts"
],
[
build: ts-circular-deps tool should normalize golden (#36505) Currently the golden output of the circular-deps tool is purely based on the order of source files passed to the tool, and on the amount of imports inside source files. This is actually resulting in deterministic output as running the tool multiple times without any changes to source files, results in the same output. Though it seems like the tool is too strict and we can avoid unnecessary golden changes if: 1. A source file that is part of a cycle is imported earlier (in terms of how the analyzer visits them). This could result in the cycle path starting with a different source file. 2. Source files which are not part of a cycle are imported earlier (in terms of how the analyzer visits them). This could result in moved items in the golden if re-approved (even though the cycles remain the same) To fix this, we normalize the cycle path array that serves as serializable data structure for the text-based goldens. Since the paths represents a cycle, the path can be shifted in a deterministic way so that cycles don't change unnecessarily in the golden, and to simplify comparison of cycles. Additionally, we sort the cycles in a deterministic way so that the golden doesn't change unnecessarily (as explained above). PR Close #36505
2020-04-08 08:50:10 -04:00
"packages/router/src/config.ts",
"packages/router/src/router_state.ts"
],
[
"packages/router/src/config.ts",
"packages/router/src/router_state.ts",
"packages/router/src/shared.ts"
],
[
"packages/router/src/directives/router_outlet.ts",
"packages/router/src/router_outlet_context.ts"
],
[
"packages/router/src/operators/activate_routes.ts",
"packages/router/src/router.ts"
],
[
"packages/router/src/operators/apply_redirects.ts",
"packages/router/src/router.ts"
],
[
"packages/router/src/operators/check_guards.ts",
"packages/router/src/router.ts"
],
[
"packages/router/src/operators/recognize.ts",
"packages/router/src/router.ts"
],
[
"packages/router/src/operators/resolve_data.ts",
"packages/router/src/router.ts"
],
[
"packages/router/src/shared.ts",
"packages/router/src/url_tree.ts"
],
[
"packages/router/src/shared.ts",
"packages/router/src/url_tree.ts",
"packages/router/src/utils/collection.ts"
ci: set up golden file for typescript circular dependencies (#35647) Sets up a golden file for the TypeScript circular dependencies for source files inside of the `packages/` folder. Also sets up the appropriate Yarn shorthand scripts, and a codeowner group that is soley responsible for verifying changes to the golden. PR Close #35647
2020-02-24 06:08:24 -05:00
]
]