From 17bc6dc5d62153ce161969667df29e103f6f67ec Mon Sep 17 00:00:00 2001 From: Craig Long Date: Sun, 1 Aug 2021 21:56:56 -0400 Subject: [PATCH 01/21] Use exisitng width, height, and camera during deserialization --- src/Libraries/Watch3DNodeModels/Watch3D.cs | 9 +++----- .../Watch3DNodeViewCustomization.cs | 23 ++++++++++++++----- 2 files changed, 20 insertions(+), 12 deletions(-) diff --git a/src/Libraries/Watch3DNodeModels/Watch3D.cs b/src/Libraries/Watch3DNodeModels/Watch3D.cs index 1acd27ee6d9..10bf91c1028 100644 --- a/src/Libraries/Watch3DNodeModels/Watch3D.cs +++ b/src/Libraries/Watch3DNodeModels/Watch3D.cs @@ -122,8 +122,8 @@ internal void OnSerialized(XmlElement element) } } - public double WatchWidth { get; private set; } - public double WatchHeight { get; private set; } + public double WatchWidth { get; set; } + public double WatchHeight { get; set; } public bool WasExecuted { get; internal set; } public delegate void VoidHandler(); @@ -134,10 +134,7 @@ internal void OnSerialized(XmlElement element) private Watch3D(IEnumerable inPorts, IEnumerable outPorts) : base(inPorts, outPorts) { ArgumentLacing = LacingStrategy.Disabled; - WatchWidth = 200; - WatchHeight = 200; ShouldDisplayPreviewCore = false; - Camera = new Watch3DCamera(); } public Watch3D() @@ -211,7 +208,7 @@ public override IEnumerable BuildOutputAst(List().FirstOrDefault(innerNode => innerNode.Name.Equals("camera", StringComparison.OrdinalIgnoreCase)); - var cameraData = watch3DViewModel.DeserializeCamera(cameraNode); - watch3DViewModel.SetCameraData(cameraData); + var camera = model.Camera; + var camData = new CameraData + { + Name = camera.Name, + EyeX = camera.EyeX, + EyeY = camera.EyeY, + EyeZ = camera.EyeZ, + LookX = camera.LookX, + LookY = camera.LookY, + LookZ = camera.LookZ, + UpX = camera.UpX, + UpY = camera.UpY, + UpZ = camera.UpZ + }; + + watch3DViewModel.SetCameraData(camData); } catch { From c497756ed4908868516fe21b9c374f199e34dabf Mon Sep 17 00:00:00 2001 From: Craig Long Date: Sun, 1 Aug 2021 22:03:51 -0400 Subject: [PATCH 02/21] Allow Watch3D to tessellate directly connected nodes independent of preview state --- src/DynamoCore/Graph/Nodes/NodeModel.cs | 22 +++++++++- .../Scheduler/UpdateRenderPackageAsyncTask.cs | 12 ++++-- .../Watch3D/DefaultWatch3DViewModel.cs | 5 +++ .../Watch3D/HelixWatch3DViewModel.cs | 4 +- .../HelixWatch3DNodeViewModel.cs | 42 +++++++++++++++++-- 5 files changed, 76 insertions(+), 9 deletions(-) diff --git a/src/DynamoCore/Graph/Nodes/NodeModel.cs b/src/DynamoCore/Graph/Nodes/NodeModel.cs index 532390e5d78..05ae86c0028 100644 --- a/src/DynamoCore/Graph/Nodes/NodeModel.cs +++ b/src/DynamoCore/Graph/Nodes/NodeModel.cs @@ -2479,6 +2479,25 @@ internal void RequestValueUpdate(EngineController engine) /// Flag which indicates if geometry update has been scheduled public virtual bool RequestVisualUpdateAsync(IScheduler scheduler, EngineController engine, IRenderPackageFactory factory, bool forceUpdate = false) + { + return RequestVisualUpdateAsync(scheduler, engine, factory, forceUpdate, false); + } + + /// + /// Call this method to asynchronously regenerate render package for + /// this node. This method accesses core properties of a NodeModel and + /// therefore is typically called on the main/UI thread. + /// + /// An IScheduler on which the task will be scheduled. + /// The EngineController which will be used to get MirrorData for the node. + /// An IRenderPackageFactory which will be used to generate IRenderPackage objects. + /// Normally, render packages are only generated when the node's IsUpdated parameter is true. + /// By setting forceUpdate to true, the render packages will be updated. + /// Normally, render packages are only generated when the node's IsVisible parameter is true. + /// By setting ignore to true, the render package will be updated. + /// Flag which indicates if geometry update has been scheduled + public virtual bool RequestVisualUpdateAsync(IScheduler scheduler, + EngineController engine, IRenderPackageFactory factory, bool forceUpdate, bool ignoreIsVisible = false) { var initParams = new UpdateRenderPackageParams() { @@ -2487,7 +2506,8 @@ public virtual bool RequestVisualUpdateAsync(IScheduler scheduler, EngineController = engine, DrawableIdMap = GetDrawableIdMap(), PreviewIdentifierName = AstIdentifierForPreview.Name, - ForceUpdate = forceUpdate + ForceUpdate = forceUpdate, + IgnoreIsVisible = ignoreIsVisible }; var task = new UpdateRenderPackageAsyncTask(scheduler); diff --git a/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs b/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs index 5b995f177c9..4d175c3db35 100644 --- a/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs +++ b/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs @@ -20,6 +20,7 @@ class UpdateRenderPackageParams internal IEnumerable> DrawableIdMap { get; set; } internal bool ForceUpdate { get; set; } + internal bool IgnoreIsVisible { get; set; } } /// @@ -87,9 +88,14 @@ internal bool Initialize(UpdateRenderPackageParams initParams) if (nodeModel.WasRenderPackageUpdatedAfterExecution && !initParams.ForceUpdate) return false; // Not has not been updated at all. - // If a node is in either of the following states, then it will not - // produce any geometric output. Bail after clearing the render packages. - if (nodeModel.IsInErrorState || !nodeModel.IsVisible) + // If a node is in an error state it won't produce any geometric output. + // Bail after clearing the render packages. + if (nodeModel.IsInErrorState) + return false; + + // If a node is not set as visible and the override is not set to true then + // bail after clearing the render packages. + if (!nodeModel.IsVisible && initParams.IgnoreIsVisible == false) return false; // Without AstIdentifierForPreview, a node cannot have MirrorData. diff --git a/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs b/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs index bc185d13bff..a254db46b07 100644 --- a/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs +++ b/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs @@ -603,6 +603,11 @@ protected virtual void OnRenderPackagesUpdated(NodeModel node, RenderPackageCach // If there is no attached model update for all render packages if (watchModel == null) { + if(node.IsVisible == false) + { + return; + } + AddGeometryForRenderPackages(packages); return; } diff --git a/src/DynamoCoreWpf/ViewModels/Watch3D/HelixWatch3DViewModel.cs b/src/DynamoCoreWpf/ViewModels/Watch3D/HelixWatch3DViewModel.cs index 09d1cd4ed65..eb9577fddeb 100644 --- a/src/DynamoCoreWpf/ViewModels/Watch3D/HelixWatch3DViewModel.cs +++ b/src/DynamoCoreWpf/ViewModels/Watch3D/HelixWatch3DViewModel.cs @@ -1078,7 +1078,7 @@ private void OnSceneItemsChanged() OnRequestViewRefresh(); } - private KeyValuePair[] FindAllGeometryModel3DsForNode(NodeModel node) + internal KeyValuePair[] FindAllGeometryModel3DsForNode(NodeModel node) { KeyValuePair[] geometryModels; @@ -1104,7 +1104,7 @@ private KeyValuePair[] FindAllGeometryModel3DsForNode(string return geometryModels; } - private void SetGeometryFrozen(HashSet gathered) + internal void SetGeometryFrozen(HashSet gathered) { foreach (var node in gathered) diff --git a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs index a7444eb0f7c..0627758f62d 100644 --- a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs +++ b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs @@ -57,11 +57,10 @@ protected internal override void UpdateUpstream() { OnClear(); - var gathered = new List(); - watchModel.VisibleUpstreamNodes(gathered); + var gathered = watchModel.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)).ToList(); gathered.ForEach(n => n.WasRenderPackageUpdatedAfterExecution = false); - gathered.ForEach(n => n.RequestVisualUpdateAsync(scheduler, engineManager.EngineController, renderPackageFactory)); + gathered.ForEach(n => n.RequestVisualUpdateAsync(scheduler, engineManager.EngineController, renderPackageFactory, false, true)); } protected override void OnModelPropertyChanged(object sender, PropertyChangedEventArgs e) @@ -74,6 +73,43 @@ protected override void OnModelPropertyChanged(object sender, PropertyChangedEve } } + protected override void OnNodePropertyChanged(object sender, PropertyChangedEventArgs e) + { + var node = sender as NodeModel; + if (node == null) + { + return; + } + + if(e.PropertyName == "CachedValue") + { + var connected = watchModel.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)); + if (!connected.Contains(node)) + { + return; + } + + node.RequestVisualUpdateAsync(scheduler, engineManager.EngineController, renderPackageFactory, true, true); + } + + if (e.PropertyName == "IsFrozen") + { + var visibleUpstream = new List(); + watchModel.VisibleUpstreamNodes(visibleUpstream); + + if (!visibleUpstream.Contains(node)) + { + return; + } + + HashSet gathered = new HashSet(); + node.GetDownstreamNodes(node, gathered); + SetGeometryFrozen(gathered); + } + + node.WasRenderPackageUpdatedAfterExecution = false; + } + protected override void PortDisconnectedHandler(PortModel obj) { OnClear(); From 0583c85b6e9cf26011d02e90c22191a012350696 Mon Sep 17 00:00:00 2001 From: Craig Long Date: Sun, 1 Aug 2021 22:04:47 -0400 Subject: [PATCH 03/21] One more change for directly connected --- .../Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs index 0627758f62d..de93cf4f038 100644 --- a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs +++ b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs @@ -122,8 +122,7 @@ protected override void OnRenderPackagesUpdated(NodeModel node, var updatedNode = dynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.GUID == node.GUID); if (updatedNode == null) return; - var visibleUpstream = new List(); - watchModel.VisibleUpstreamNodes(visibleUpstream); + var visibleUpstream = watchModel.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)).ToList(); if (!visibleUpstream.Contains(updatedNode)) { From d81582e985590a967f167cd002cbfa048db1acca Mon Sep 17 00:00:00 2001 From: Craig Long Date: Sun, 1 Aug 2021 22:05:23 -0400 Subject: [PATCH 04/21] Fix bug with port connection and disconnect events --- .../Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs index de93cf4f038..489f9a1f18c 100644 --- a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs +++ b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs @@ -50,7 +50,10 @@ void watchNode_Deserialized(XmlNode obj) protected override void PortConnectedHandler(PortModel arg1, ConnectorModel arg2) { - UpdateUpstream(); + if (arg1.PortType == PortType.Input && watchModel == arg1.Owner) + { + UpdateUpstream(); + } } protected internal override void UpdateUpstream() @@ -112,7 +115,10 @@ protected override void OnNodePropertyChanged(object sender, PropertyChangedEven protected override void PortDisconnectedHandler(PortModel obj) { - OnClear(); + if (obj.PortType == PortType.Input && watchModel == obj.Owner) + { + OnClear(); + } } From b073fc363ef1e94b1938bb03b7ac26a9eb4a0d39 Mon Sep 17 00:00:00 2001 From: Craig Long Date: Mon, 8 Nov 2021 13:39:29 -0500 Subject: [PATCH 05/21] pr comments --- .../Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs index 489f9a1f18c..b3470f7f396 100644 --- a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs +++ b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs @@ -84,7 +84,7 @@ protected override void OnNodePropertyChanged(object sender, PropertyChangedEven return; } - if(e.PropertyName == "CachedValue") + if(e.PropertyName == nameof(node.CachedValue)) { var connected = watchModel.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)); if (!connected.Contains(node)) @@ -105,7 +105,7 @@ protected override void OnNodePropertyChanged(object sender, PropertyChangedEven return; } - HashSet gathered = new HashSet(); + var gathered = new HashSet(); node.GetDownstreamNodes(node, gathered); SetGeometryFrozen(gathered); } From c1c9b17fd97612a9ba0e551ea817dad475a0a5cf Mon Sep 17 00:00:00 2001 From: Craig Long Date: Fri, 4 Nov 2022 15:05:21 -0700 Subject: [PATCH 06/21] Ignore certain cases --- src/DynamoCoreWpf/DynamoCoreWpf.csproj | 5 +++++ .../ViewModels/Watch3D/DefaultWatch3DViewModel.cs | 4 +++- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/DynamoCoreWpf/DynamoCoreWpf.csproj b/src/DynamoCoreWpf/DynamoCoreWpf.csproj index 8d2e8bf10d4..55ea3d413bd 100644 --- a/src/DynamoCoreWpf/DynamoCoreWpf.csproj +++ b/src/DynamoCoreWpf/DynamoCoreWpf.csproj @@ -1446,6 +1446,11 @@ {ccb6e56b-2da1-4eba-a1f9-e8510e129d12} VMDataBridge + + {31183026-DE70-49CB-BC7C-0DFD0A088F62} + Watch3DNodeModels + False + {ef879a10-041d-4c68-83e7-3192685f1bae} DynamoServices diff --git a/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs b/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs index 2eba48b5f39..46b04cf78bd 100644 --- a/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs +++ b/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs @@ -8,6 +8,7 @@ using System.Windows.Media; using System.Windows.Media.Media3D; using System.Xml; +using CoreNodeModels; using Dynamo.Core; using Dynamo.Graph.Connectors; using Dynamo.Graph.Nodes; @@ -610,7 +611,8 @@ protected virtual void OnRenderPackagesUpdated(NodeModel node, RenderPackageCach // If there is no attached model update for all render packages if (watchModel == null) { - if(node.IsVisible == false) + //When Watch3D nodes are in canvis we need to ignore this even under certain situations. + if (node.IsVisible == false || node is Watch || node is Watch3DNodeModels.Watch3D) { return; } From a6244c30870032cd42ecea9959945b8fa3558342 Mon Sep 17 00:00:00 2001 From: Craig Long Date: Fri, 4 Nov 2022 15:12:23 -0700 Subject: [PATCH 07/21] PR comments --- .../Graph/Nodes/NodeModelExtensions.cs | 5 ++++ .../HelixWatch3DNodeViewModel.cs | 25 ++++++++----------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs b/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs index ca225bd80c3..f1df64f2606 100644 --- a/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs +++ b/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs @@ -23,6 +23,11 @@ internal static void VisibleUpstreamNodes(this NodeModel node, List g } } + internal static HashSet ImediateUpstreamNodes(this NodeModel node) + { + return node.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)).ToHashSet(); + } + internal static IEnumerable UpstreamNodesMatchingPredicate(this NodeModel node, List gathered, Predicate match) { var upstream = node.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)). diff --git a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs index b3470f7f396..8126cf1ec79 100644 --- a/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs +++ b/src/Libraries/Watch3DNodeModelsWpf/HelixWatch3DNodeViewModel.cs @@ -60,10 +60,13 @@ protected internal override void UpdateUpstream() { OnClear(); - var gathered = watchModel.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)).ToList(); + var connectedNodes = watchModel.ImediateUpstreamNodes(); - gathered.ForEach(n => n.WasRenderPackageUpdatedAfterExecution = false); - gathered.ForEach(n => n.RequestVisualUpdateAsync(scheduler, engineManager.EngineController, renderPackageFactory, false, true)); + foreach(var n in connectedNodes) + { + n.WasRenderPackageUpdatedAfterExecution = false; + n.RequestVisualUpdateAsync(scheduler, engineManager.EngineController, renderPackageFactory, false, true); + } } protected override void OnModelPropertyChanged(object sender, PropertyChangedEventArgs e) @@ -86,8 +89,8 @@ protected override void OnNodePropertyChanged(object sender, PropertyChangedEven if(e.PropertyName == nameof(node.CachedValue)) { - var connected = watchModel.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)); - if (!connected.Contains(node)) + var connecteNodes = watchModel.ImediateUpstreamNodes(); + if (!connecteNodes.Contains(node)) { return; } @@ -97,10 +100,7 @@ protected override void OnNodePropertyChanged(object sender, PropertyChangedEven if (e.PropertyName == "IsFrozen") { - var visibleUpstream = new List(); - watchModel.VisibleUpstreamNodes(visibleUpstream); - - if (!visibleUpstream.Contains(node)) + if (!watchModel.UpstreamCache.Contains(node)) { return; } @@ -125,12 +125,9 @@ protected override void PortDisconnectedHandler(PortModel obj) protected override void OnRenderPackagesUpdated(NodeModel node, RenderPackageCache renderPackages) { - var updatedNode = dynamoModel.CurrentWorkspace.Nodes.FirstOrDefault(n => n.GUID == node.GUID); - if (updatedNode == null) return; - - var visibleUpstream = watchModel.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)).ToList(); + var connectedNodes = watchModel.ImediateUpstreamNodes(); - if (!visibleUpstream.Contains(updatedNode)) + if (!connectedNodes.Contains(node)) { return; } From 1d0c23a42df07a0925b61fae6a617ff857be930c Mon Sep 17 00:00:00 2001 From: Craig Long Date: Fri, 4 Nov 2022 20:09:45 -0700 Subject: [PATCH 08/21] update comments --- src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs | 5 +++++ src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs | 3 +++ 2 files changed, 8 insertions(+) diff --git a/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs b/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs index f1df64f2606..5c787cc1f8a 100644 --- a/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs +++ b/src/DynamoCore/Graph/Nodes/NodeModelExtensions.cs @@ -23,6 +23,11 @@ internal static void VisibleUpstreamNodes(this NodeModel node, List g } } + /// + /// Provide the upstream nodes that are imediately connected. + /// + /// + /// internal static HashSet ImediateUpstreamNodes(this NodeModel node) { return node.InPorts.SelectMany(p => p.Connectors.Select(c => c.Start.Owner)).ToHashSet(); diff --git a/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs b/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs index 7fba6c9f148..da57ec951bf 100644 --- a/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs +++ b/src/DynamoCore/Scheduler/UpdateRenderPackageAsyncTask.cs @@ -21,6 +21,9 @@ class UpdateRenderPackageParams internal IEnumerable> DrawableIdMap { get; set; } internal bool ForceUpdate { get; set; } + /// + /// Set to true to ignore the preview state of the node + /// internal bool IgnoreIsVisible { get; set; } } From 749beb7cebfc822179352b9a2b0061258d237eb2 Mon Sep 17 00:00:00 2001 From: Craig Long Date: Wed, 9 Nov 2022 08:59:21 -0700 Subject: [PATCH 09/21] Update DefaultWatch3DViewModel.cs --- .../ViewModels/Watch3D/DefaultWatch3DViewModel.cs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs b/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs index 46b04cf78bd..63ef7b814f6 100644 --- a/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs +++ b/src/DynamoCoreWpf/ViewModels/Watch3D/DefaultWatch3DViewModel.cs @@ -611,7 +611,10 @@ protected virtual void OnRenderPackagesUpdated(NodeModel node, RenderPackageCach // If there is no attached model update for all render packages if (watchModel == null) { - //When Watch3D nodes are in canvis we need to ignore this even under certain situations. + //When Watch3D nodes are in canvas we need to ignore the Node.RenderPackageUpdate event in some cases. + //The background preview does not request tesselation for non-visible nodes or the Watch / Watch3D nodes. + //When these nodes are connected to a Watch3D, tesselation is requested and the Node.RenderPacakgeUpdate + //event will be raised. The background preview needs to filter out those tesselation events. if (node.IsVisible == false || node is Watch || node is Watch3DNodeModels.Watch3D) { return; From 71a4c2867d6c9b7e8eb25f08ad7eb2bb9b80bf54 Mon Sep 17 00:00:00 2001 From: Long Nguyen Date: Fri, 11 Nov 2022 19:45:01 +0700 Subject: [PATCH 10/21] Added deserialization test for HelixWatch3D node --- .../HelixWatch3DViewModelTests.cs | 73 +++++++++++-------- 1 file changed, 41 insertions(+), 32 deletions(-) diff --git a/src/VisualizationTests/HelixWatch3DViewModelTests.cs b/src/VisualizationTests/HelixWatch3DViewModelTests.cs index f6324d13cb5..c74f552cd0e 100644 --- a/src/VisualizationTests/HelixWatch3DViewModelTests.cs +++ b/src/VisualizationTests/HelixWatch3DViewModelTests.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Drawing; using System.IO; @@ -40,7 +40,7 @@ namespace WpfVisualizationTests /// /// The standard SystemTestBase uses a DefaultWatch3DViewModel. /// In order to test visualizations, the VisualizationTest class, - /// uses a HelixWatch3DViewModel supplied as part of the + /// uses a HelixWatch3DViewModel supplied as part of the /// DynamoViewModel's start configuration. /// public class VisualizationTest : SystemTestBase @@ -207,6 +207,15 @@ public void Node_RenderingUpToDate() Assert.AreEqual(BackgroundPreviewGeometry.NumberOfInvisibleCurves(), 0); } + [Test] + public void Node_CameraDeserialization() + { + OpenVisualizationTest("HelixWatch3dNodeViewModel_Camera_Deserialization.dyn"); + var helixNodeViewModel = FindFirstWatch3DNodeView().ViewModel as HelixWatch3DNodeViewModel; + Assert.NotNull(helixNodeViewModel); + Assert.AreEqual(helixNodeViewModel.Camera.Position.X, 48.66565, 0.01); + } + [Test] public void Node_PreviewToggled_RenderingUpToDate() { @@ -223,7 +232,7 @@ public void Node_PreviewToggled_RenderingUpToDate() var view = FindFirstWatch3DNodeView(); var vm = view.ViewModel as HelixWatch3DNodeViewModel; Assert.NotNull(vm); - + Assert.True(vm.SceneItems.HasNumberOfPointsCurvesAndMeshes(0,6,0)); } @@ -471,9 +480,9 @@ public void Geometry_Planes_Render() // 5 planes, each with two triangles: // 30 mesh vertices - //ensure that the number of visualizations matches the + //ensure that the number of visualizations matches the //number of pieces of geometry in the collection - Assert.AreEqual(numberOfPlanes * numberOfVertsPerTri * numberOfTrisPerPlane, + Assert.AreEqual(numberOfPlanes * numberOfVertsPerTri * numberOfTrisPerPlane, BackgroundPreviewGeometry.TotalMeshVerticesToRender()); var testColor = new Color4(0, 0, 0, 10.0f / 255.0f); @@ -482,7 +491,7 @@ public void Geometry_Planes_Render() // Increase the number of planes numberOfPlanes = numberOfPlanes + 5; numberOfPlanesNode.Value = numberOfPlanes.ToString(); - Assert.AreEqual(numberOfPlanes * numberOfVertsPerTri * numberOfTrisPerPlane, + Assert.AreEqual(numberOfPlanes * numberOfVertsPerTri * numberOfTrisPerPlane, BackgroundPreviewGeometry.TotalMeshVerticesToRender()); } @@ -807,23 +816,23 @@ public void Display_ByGeometryColor_HasColoredMesh() var numberOfColors = dynGeometry.Geometry.Colors.Count; Assert.AreEqual(36, numberOfColors); - // Expecting they are all the same solid color assigning as a result + // Expecting they are all the same solid color assigning as a result // of DesignScript "Color.ByARGB(255,255,0,255);" Assert.AreEqual(true, dynGeometry.Geometry.Colors.All(color => color.Alpha == 1)); Assert.AreEqual(true, dynGeometry.Geometry.Colors.All(color => color.Red == 1)); Assert.AreEqual(true, dynGeometry.Geometry.Colors.All(color => color.Green == 0)); Assert.AreEqual(true, dynGeometry.Geometry.Colors.All(color => color.Blue == 1)); } - + [Test] public void Display_Geometry_Labels() { OpenVisualizationTest("Labels.dyn"); var ws = ViewModel.Model.CurrentWorkspace as HomeWorkspaceModel; - + RunCurrentModel(); - // This is the node, for which we would display the Labels in the preview geometry. + // This is the node, for which we would display the Labels in the preview geometry. var codeBlockGUID = "fdec3b9b-56ae-4d01-85c2-47b8425e3130"; NodeModel codeBlockNodeModel = ws.Nodes.Where(node => node.GUID.ToString() == codeBlockGUID).FirstOrDefault(); @@ -832,21 +841,21 @@ public void Display_Geometry_Labels() var helix = ViewModel.BackgroundPreviewViewModel as HelixWatch3DViewModel; - // By default the DisplayLabels for the code block node is set to false, - // so the Model3DDictionary wouldn't have the geometry object corresponding to the Labels. - var geometryHasLabels = helix.Element3DDictionary.ContainsKey(labelKey); + // By default the DisplayLabels for the code block node is set to false, + // so the Model3DDictionary wouldn't have the geometry object corresponding to the Labels. + var geometryHasLabels = helix.Element3DDictionary.ContainsKey(labelKey); Assert.IsFalse(geometryHasLabels); // We set the DisplayLabels to true to view the Labels in the preview geometry. codeBlockNodeModel.DisplayLabels = true; - // Now the Labels are shown in the preview geometry. - // The code block node has 64 points, so there should be 64 labels. + // Now the Labels are shown in the preview geometry. + // The code block node has 64 points, so there should be 64 labels. var geometryWithLabels = (helix.Element3DDictionary[labelKey] as GeometryModel3D).Geometry as BillboardText3D; Assert.AreEqual(64, geometryWithLabels.TextInfo.Count); // Clicking on a single value from the output of the watch node - // should show only one label corresponding to that value. + // should show only one label corresponding to that value. var nodeView = View.ChildrenOfType().First(nv => nv.ViewModel.Name == "Watch"); var treeViewItem = nodeView.ChildOfType(); @@ -866,7 +875,7 @@ public void Display_Geometry_Labels() DispatcherUtil.DoEvents(); - // The value selected is x:0, y:0 and z:1, + // The value selected is x:0, y:0 and z:1, // so the label that is shown should be [0,0,1]. var geometry = (helix.Element3DDictionary[labelKey] as GeometryModel3D).Geometry as BillboardText3D; Assert.AreEqual(1, geometry.TextInfo.Count); @@ -874,10 +883,10 @@ public void Display_Geometry_Labels() } [Test] - // This test will select a sphere object 30 times from a list of sphere's, to display + // This test will select a sphere object 30 times from a list of sphere's, to display // the corresponding label for that sphere object. After the Helix update, this workflow was causing // delays and would cause dynamo to hang. The fix was added in this PR: https://github.com/DynamoDS/Dynamo/pull/10399 - // Before the fix, this test would take around 5 mins to finish but now this test finishes in just 20 secs. + // Before the fix, this test would take around 5 mins to finish but now this test finishes in just 20 secs. public void PerformanceTestOnLabelsAfterHelixUpgrade() { System.DateTime startTime = System.DateTime.Now; @@ -895,11 +904,11 @@ public void PerformanceTestOnLabelsAfterHelixUpgrade() var helix = ViewModel.BackgroundPreviewViewModel as HelixWatch3DViewModel; // Clicking on a single value from the output of the watch node - // should show only one label corresponding to that value. + // should show only one label corresponding to that value. var nodeView = View.ChildrenOfType().First(nv => nv.ViewModel.Name == "Watch"); var parentTreeViewItem = nodeView.ChildOfType(); - // Selcting a sphere object 70 different times to render new labels again. + // Selcting a sphere object 70 different times to render new labels again. for (int i = 0; i < 30; i++) { @@ -924,7 +933,7 @@ public void PerformanceTestOnLabelsAfterHelixUpgrade() var totalExecutionTime = (endTime - startTime).TotalSeconds; Assert.LessOrEqual(totalExecutionTime, 20); } - + [Test] public void Display_BySurfaceColors_HasColoredMesh() { @@ -975,7 +984,7 @@ public void Display_MultipleTextureMaps_HasUniqueMeshsAndCorrectPerSurface() //Mesh 3 is has no texture map var mesh3 = meshes[2]; - + Assert.IsTrue(((PhongMaterial)mesh3.Material).DiffuseMap == null); } @@ -990,7 +999,7 @@ public void Display_HasOneGeometryEntityInBackgroundPreviewPerNode() Assert.AreEqual(1, BackgroundPreviewGeometry.NumberOfVisibleMeshes()); Assert.AreEqual(1, BackgroundPreviewGeometry.NumberOfVisibleCurves()); - + Assert.AreEqual(1, BackgroundPreviewGeometry.NumberOfVisiblePoints()); } @@ -1156,7 +1165,7 @@ public void MAGN9434_DisablePreview() [Category("RegressionTests")] public void CanTagGeometryWhenClickingSingleItemInPreviewBubble() { - tagGeometryWhenClickingItem(new[] {0, 0}, 1, "Point.ByCoordinates", + tagGeometryWhenClickingItem(new[] {0, 0}, 1, "Point.ByCoordinates", n => n.ViewModel.NodeModel, true); } @@ -1180,11 +1189,11 @@ public void CanTagGeometryWhenClickingSingleItemInWatchNode() [Category("RegressionTests")] public void CanTagGeometryWhenClickingArrayItemInWatchNode() { - tagGeometryWhenClickingItem(new[] { 0 }, 11, "Watch", + tagGeometryWhenClickingItem(new[] { 0 }, 11, "Watch", n => n.ViewModel.NodeModel.InPorts[0].Connectors[0].Start.Owner); } - - private async void tagGeometryWhenClickingItem(int[] indexes, int expectedNumberOfLabels, + + private async void tagGeometryWhenClickingItem(int[] indexes, int expectedNumberOfLabels, string nodeName, Func getGeometryOwnerNode, bool expandPreviewBubble = false) { OpenVisualizationTest("MAGN_3815.dyn"); @@ -1311,7 +1320,7 @@ public void InstancedMeshesAndLinesAreAddedToBackGroundPreviewForEachMatrixWhenS Assert.AreEqual(3, BackgroundPreviewGeometry.NumberOfVisibleCurves()); //cone and mesh Assert.AreEqual(2, BackgroundPreviewGeometry.NumberOfVisibleMeshes()); - + // cube instance edges Assert.AreEqual(5 * 5 * 5, BackgroundPreviewGeometry.TotalLineInstancesToRender()); // cube instance meshes @@ -1328,7 +1337,7 @@ public void InstancedShowEdgesAreCorrect() //assert cube is created not at origin. var result = GetPreviewValue("2264fad6b59640d0b753ba81c1f53f43").ToString(); Assert.AreEqual("Point(X = 2.000, Y = 2.000, Z = 2.000)",result); - + ViewModel.RenderPackageFactoryViewModel.ShowEdges = true; // assert that the cube edges have been tessellated back at origin. @@ -1387,7 +1396,7 @@ public static int TotalPoints(this IEnumerable dictionary) /// /// Returns the total number of DynamoGeometryModel3D objects. - /// + /// /// Each DynamoGeometryModel3D object may contain more than one mesh. /// /// @@ -1479,7 +1488,7 @@ public static int TotalCurveVerticesOfColor(this IEnumerable dictiona return geoms.Sum(g => g.Geometry.Colors.Count(c => c == color)); } - public static bool HasNumberOfPointsCurvesAndMeshes(this IEnumerable dictionary, int numberOfPoints, + public static bool HasNumberOfPointsCurvesAndMeshes(this IEnumerable dictionary, int numberOfPoints, int numberOfCurves, int numberOfMeshes) { return dictionary.TotalPoints() == numberOfPoints && From 03ceb2e7a41f883f6e5f68ee11cf205c322ced3d Mon Sep 17 00:00:00 2001 From: Long Nguyen Date: Fri, 11 Nov 2022 20:11:22 +0700 Subject: [PATCH 11/21] Added the dyn file for the HelixWatch3D node deserialization test --- ...3dNodeViewModel_Camera_Deserialization.dyn | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn diff --git a/test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn b/test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn new file mode 100644 index 00000000000..de753d4ef15 --- /dev/null +++ b/test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn @@ -0,0 +1,117 @@ +{ + "Uuid": "73f963c0-e599-4348-8351-6f4c8c574eee", + "IsCustomNode": false, + "Description": "", + "Name": "HelixWatch3dNodeViewModel_Camera_Deserialization", + "ElementResolver": { + "ResolutionMap": {} + }, + "Inputs": [], + "Outputs": [], + "Nodes": [ + { + "ConcreteType": "Watch3DNodeModels.Watch3D, Watch3DNodeModels", + "WatchWidth": 200.0, + "WatchHeight": 200.0, + "WasExecuted": true, + "Camera": { + "Name": "b29a7fbc-301d-4751-8c8a-87c73792cd26 Preview", + "EyeX": 48.665657043457031, + "EyeY": 16.929214477539063, + "EyeZ": 28.72308349609375, + "LookX": -37.730476379394531, + "LookY": -14.288958549499512, + "LookZ": -45.268463134765625, + "UpX": -0.013966959901154041, + "UpY": 0.99976199865341187, + "UpZ": -0.016757408156991005 + }, + "NodeType": "ExtensionNode", + "Id": "b29a7fbc301d47518c8a87c73792cd26", + "Inputs": [ + { + "Id": "c379c85580cf472b81e3fb14474e3bfd", + "Name": "", + "Description": "Incoming geometry objects.", + "UsingDefaultValue": false, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Outputs": [ + { + "Id": "a5278789a68c45bab96a8111a0ed281a", + "Name": "", + "Description": "Incoming geometry objects.", + "UsingDefaultValue": false, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Replication": "Disabled", + "Description": "Shows a dynamic preview of geometry" + } + ], + "Connectors": [], + "Dependencies": [], + "NodeLibraryDependencies": [], + "Thumbnail": "", + "GraphDocumentationURL": null, + "ExtensionWorkspaceData": [ + { + "ExtensionGuid": "28992e1d-abb9-417f-8b1b-05e053bee670", + "Name": "Properties", + "Version": "2.17", + "Data": {} + } + ], + "Author": "", + "Linting": { + "activeLinter": "None", + "activeLinterId": "7b75fb44-43fd-4631-a878-29f4d5d8399a", + "warningCount": 0, + "errorCount": 0 + }, + "Bindings": [], + "View": { + "Dynamo": { + "ScaleFactor": 1.0, + "HasRunWithoutCrash": true, + "IsVisibleInDynamoLibrary": true, + "Version": "2.17.0.2986", + "RunType": "Automatic", + "RunPeriod": "1000" + }, + "Camera": { + "Name": "_Background Preview", + "EyeX": -17.0, + "EyeY": 24.0, + "EyeZ": 50.0, + "LookX": 12.0, + "LookY": -13.0, + "LookZ": -58.0, + "UpX": 0.0, + "UpY": 1.0, + "UpZ": 0.0 + }, + "ConnectorPins": [], + "NodeViews": [ + { + "Name": "Watch 3D", + "ShowGeometry": true, + "Id": "b29a7fbc301d47518c8a87c73792cd26", + "IsSetAsInput": false, + "IsSetAsOutput": false, + "Excluded": false, + "X": 452.5, + "Y": 220.0 + } + ], + "Annotations": [], + "X": 0.0, + "Y": 0.0, + "Zoom": 1.0 + } +} \ No newline at end of file From 372284d20df0f819bbc01f4ba95c6e890b34c6f5 Mon Sep 17 00:00:00 2001 From: Long Nguyen Date: Sat, 12 Nov 2022 10:00:39 +0700 Subject: [PATCH 12/21] Added testing for Width deserialization --- .../HelixWatch3DViewModelTests.cs | 11 +- ...3dNodeViewModel_Camera_Deserialization.dyn | 117 ------------------ 2 files changed, 7 insertions(+), 121 deletions(-) delete mode 100644 test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn diff --git a/src/VisualizationTests/HelixWatch3DViewModelTests.cs b/src/VisualizationTests/HelixWatch3DViewModelTests.cs index c74f552cd0e..c09d28967c7 100644 --- a/src/VisualizationTests/HelixWatch3DViewModelTests.cs +++ b/src/VisualizationTests/HelixWatch3DViewModelTests.cs @@ -208,12 +208,15 @@ public void Node_RenderingUpToDate() } [Test] - public void Node_CameraDeserialization() + public void Node_PropertiesDeserialization() { - OpenVisualizationTest("HelixWatch3dNodeViewModel_Camera_Deserialization.dyn"); - var helixNodeViewModel = FindFirstWatch3DNodeView().ViewModel as HelixWatch3DNodeViewModel; + OpenVisualizationTest("HelixWatch3dNodeViewModel_PropertiesDeserialization.dyn"); + Watch3DView view = FindFirstWatch3DNodeView(); + Assert.NotNull(view); + Assert.AreEqual(300.0, view.Width); + HelixWatch3DNodeViewModel helixNodeViewModel = view.ViewModel as HelixWatch3DNodeViewModel; Assert.NotNull(helixNodeViewModel); - Assert.AreEqual(helixNodeViewModel.Camera.Position.X, 48.66565, 0.01); + Assert.AreEqual(48.66565, helixNodeViewModel.Camera.Position.X, 0.01); } [Test] diff --git a/test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn b/test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn deleted file mode 100644 index de753d4ef15..00000000000 --- a/test/core/visualization/HelixWatch3dNodeViewModel_Camera_Deserialization.dyn +++ /dev/null @@ -1,117 +0,0 @@ -{ - "Uuid": "73f963c0-e599-4348-8351-6f4c8c574eee", - "IsCustomNode": false, - "Description": "", - "Name": "HelixWatch3dNodeViewModel_Camera_Deserialization", - "ElementResolver": { - "ResolutionMap": {} - }, - "Inputs": [], - "Outputs": [], - "Nodes": [ - { - "ConcreteType": "Watch3DNodeModels.Watch3D, Watch3DNodeModels", - "WatchWidth": 200.0, - "WatchHeight": 200.0, - "WasExecuted": true, - "Camera": { - "Name": "b29a7fbc-301d-4751-8c8a-87c73792cd26 Preview", - "EyeX": 48.665657043457031, - "EyeY": 16.929214477539063, - "EyeZ": 28.72308349609375, - "LookX": -37.730476379394531, - "LookY": -14.288958549499512, - "LookZ": -45.268463134765625, - "UpX": -0.013966959901154041, - "UpY": 0.99976199865341187, - "UpZ": -0.016757408156991005 - }, - "NodeType": "ExtensionNode", - "Id": "b29a7fbc301d47518c8a87c73792cd26", - "Inputs": [ - { - "Id": "c379c85580cf472b81e3fb14474e3bfd", - "Name": "", - "Description": "Incoming geometry objects.", - "UsingDefaultValue": false, - "Level": 2, - "UseLevels": false, - "KeepListStructure": false - } - ], - "Outputs": [ - { - "Id": "a5278789a68c45bab96a8111a0ed281a", - "Name": "", - "Description": "Incoming geometry objects.", - "UsingDefaultValue": false, - "Level": 2, - "UseLevels": false, - "KeepListStructure": false - } - ], - "Replication": "Disabled", - "Description": "Shows a dynamic preview of geometry" - } - ], - "Connectors": [], - "Dependencies": [], - "NodeLibraryDependencies": [], - "Thumbnail": "", - "GraphDocumentationURL": null, - "ExtensionWorkspaceData": [ - { - "ExtensionGuid": "28992e1d-abb9-417f-8b1b-05e053bee670", - "Name": "Properties", - "Version": "2.17", - "Data": {} - } - ], - "Author": "", - "Linting": { - "activeLinter": "None", - "activeLinterId": "7b75fb44-43fd-4631-a878-29f4d5d8399a", - "warningCount": 0, - "errorCount": 0 - }, - "Bindings": [], - "View": { - "Dynamo": { - "ScaleFactor": 1.0, - "HasRunWithoutCrash": true, - "IsVisibleInDynamoLibrary": true, - "Version": "2.17.0.2986", - "RunType": "Automatic", - "RunPeriod": "1000" - }, - "Camera": { - "Name": "_Background Preview", - "EyeX": -17.0, - "EyeY": 24.0, - "EyeZ": 50.0, - "LookX": 12.0, - "LookY": -13.0, - "LookZ": -58.0, - "UpX": 0.0, - "UpY": 1.0, - "UpZ": 0.0 - }, - "ConnectorPins": [], - "NodeViews": [ - { - "Name": "Watch 3D", - "ShowGeometry": true, - "Id": "b29a7fbc301d47518c8a87c73792cd26", - "IsSetAsInput": false, - "IsSetAsOutput": false, - "Excluded": false, - "X": 452.5, - "Y": 220.0 - } - ], - "Annotations": [], - "X": 0.0, - "Y": 0.0, - "Zoom": 1.0 - } -} \ No newline at end of file From e8a003bd04c1d51b3589c6c48de332f5d5f678e8 Mon Sep 17 00:00:00 2001 From: Long Nguyen Date: Sat, 12 Nov 2022 10:09:55 +0700 Subject: [PATCH 13/21] Renamed test dyn file --- ...odeViewModel_PropertiesDeserialization.dyn | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) create mode 100644 test/core/visualization/HelixWatch3dNodeViewModel_PropertiesDeserialization.dyn diff --git a/test/core/visualization/HelixWatch3dNodeViewModel_PropertiesDeserialization.dyn b/test/core/visualization/HelixWatch3dNodeViewModel_PropertiesDeserialization.dyn new file mode 100644 index 00000000000..f27d52f0d83 --- /dev/null +++ b/test/core/visualization/HelixWatch3dNodeViewModel_PropertiesDeserialization.dyn @@ -0,0 +1,117 @@ +{ + "Uuid": "73f963c0-e599-4348-8351-6f4c8c574eee", + "IsCustomNode": false, + "Description": "", + "Name": "HelixWatch3dNodeViewModel_Camera_Deserialization", + "ElementResolver": { + "ResolutionMap": {} + }, + "Inputs": [], + "Outputs": [], + "Nodes": [ + { + "ConcreteType": "Watch3DNodeModels.Watch3D, Watch3DNodeModels", + "WatchWidth": 300.0, + "WatchHeight": 200.0, + "WasExecuted": true, + "Camera": { + "Name": "b29a7fbc-301d-4751-8c8a-87c73792cd26 Preview", + "EyeX": 48.665657043457031, + "EyeY": 16.929214477539063, + "EyeZ": 28.72308349609375, + "LookX": -37.730476379394531, + "LookY": -14.288958549499512, + "LookZ": -45.268463134765625, + "UpX": -0.013966959901154041, + "UpY": 0.99976199865341187, + "UpZ": -0.016757408156991005 + }, + "NodeType": "ExtensionNode", + "Id": "b29a7fbc301d47518c8a87c73792cd26", + "Inputs": [ + { + "Id": "c379c85580cf472b81e3fb14474e3bfd", + "Name": "", + "Description": "Incoming geometry objects.", + "UsingDefaultValue": false, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Outputs": [ + { + "Id": "a5278789a68c45bab96a8111a0ed281a", + "Name": "", + "Description": "Incoming geometry objects.", + "UsingDefaultValue": false, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Replication": "Disabled", + "Description": "Shows a dynamic preview of geometry" + } + ], + "Connectors": [], + "Dependencies": [], + "NodeLibraryDependencies": [], + "Thumbnail": "", + "GraphDocumentationURL": null, + "ExtensionWorkspaceData": [ + { + "ExtensionGuid": "28992e1d-abb9-417f-8b1b-05e053bee670", + "Name": "Properties", + "Version": "2.17", + "Data": {} + } + ], + "Author": "", + "Linting": { + "activeLinter": "None", + "activeLinterId": "7b75fb44-43fd-4631-a878-29f4d5d8399a", + "warningCount": 0, + "errorCount": 0 + }, + "Bindings": [], + "View": { + "Dynamo": { + "ScaleFactor": 1.0, + "HasRunWithoutCrash": true, + "IsVisibleInDynamoLibrary": true, + "Version": "2.17.0.2986", + "RunType": "Automatic", + "RunPeriod": "1000" + }, + "Camera": { + "Name": "_Background Preview", + "EyeX": -17.0, + "EyeY": 24.0, + "EyeZ": 50.0, + "LookX": 12.0, + "LookY": -13.0, + "LookZ": -58.0, + "UpX": 0.0, + "UpY": 1.0, + "UpZ": 0.0 + }, + "ConnectorPins": [], + "NodeViews": [ + { + "Name": "Watch 3D", + "ShowGeometry": true, + "Id": "b29a7fbc301d47518c8a87c73792cd26", + "IsSetAsInput": false, + "IsSetAsOutput": false, + "Excluded": false, + "X": 452.5, + "Y": 220.0 + } + ], + "Annotations": [], + "X": 0.0, + "Y": 0.0, + "Zoom": 1.0 + } +} \ No newline at end of file From 77de095e00d54f8b1fb27095cbfe8310f9904b2b Mon Sep 17 00:00:00 2001 From: Long Nguyen Date: Mon, 14 Nov 2022 20:13:33 +0700 Subject: [PATCH 14/21] Added test for ignoring IsVisible parameter by Watch3d node --- .../HelixWatch3DViewModelTests.cs | 15 ++ ...ixWatch3dNodeViewModel_IgnoreIsVisible.dyn | 182 ++++++++++++++++++ 2 files changed, 197 insertions(+) create mode 100644 test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn diff --git a/src/VisualizationTests/HelixWatch3DViewModelTests.cs b/src/VisualizationTests/HelixWatch3DViewModelTests.cs index c09d28967c7..79d011a209e 100644 --- a/src/VisualizationTests/HelixWatch3DViewModelTests.cs +++ b/src/VisualizationTests/HelixWatch3DViewModelTests.cs @@ -219,6 +219,21 @@ public void Node_PropertiesDeserialization() Assert.AreEqual(48.66565, helixNodeViewModel.Camera.Position.X, 0.01); } + /// + /// This test uses a Dynamo graph that has a sphere creation node (with Preview disabled) connected to a Watch3D node. + /// It ensures that the Watch3D still renders the sphere. + /// + [Test] + public void Node_IgnoreIsVisible() + { + OpenVisualizationTest("HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn"); + Watch3DView view = FindFirstWatch3DNodeView(); + Assert.NotNull(view); + HelixWatch3DNodeViewModel helixNodeViewModel = view.ViewModel as HelixWatch3DNodeViewModel; + Assert.NotNull(helixNodeViewModel); + Assert.True(helixNodeViewModel.SceneItems.HasNumberOfPointsCurvesAndMeshes(0, 0, 1)); + } + [Test] public void Node_PreviewToggled_RenderingUpToDate() { diff --git a/test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn b/test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn new file mode 100644 index 00000000000..462193b6a68 --- /dev/null +++ b/test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn @@ -0,0 +1,182 @@ +{ + "Uuid": "8d0af5dc-b8ab-4f54-bd46-ba9885a00262", + "IsCustomNode": false, + "Description": "", + "Name": "HelixWatch3dNodeViewModel_IgnoreIsVisible", + "ElementResolver": { + "ResolutionMap": {} + }, + "Inputs": [], + "Outputs": [], + "Nodes": [ + { + "ConcreteType": "Watch3DNodeModels.Watch3D, Watch3DNodeModels", + "WatchWidth": 200.0, + "WatchHeight": 200.0, + "WasExecuted": true, + "Camera": { + "Name": "c59ed620-269a-44d6-8540-edba42d7fd04 Preview", + "EyeX": -17.0, + "EyeY": 24.0, + "EyeZ": 50.0, + "LookX": 12.0, + "LookY": -13.0, + "LookZ": -58.0, + "UpX": 0.0, + "UpY": 1.0, + "UpZ": 0.0 + }, + "NodeType": "ExtensionNode", + "Id": "c59ed620269a44d68540edba42d7fd04", + "Inputs": [ + { + "Id": "72f6cbed9a1a470e8db57a6b523ed94f", + "Name": "", + "Description": "Incoming geometry objects.", + "UsingDefaultValue": false, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Outputs": [ + { + "Id": "c4285b43e30f4d19a96ff1f6b1f9928b", + "Name": "", + "Description": "Incoming geometry objects.", + "UsingDefaultValue": false, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Replication": "Disabled", + "Description": "Shows a dynamic preview of geometry" + }, + { + "ConcreteType": "Dynamo.Graph.Nodes.ZeroTouch.DSFunction, DynamoCore", + "NodeType": "FunctionNode", + "FunctionSignature": "Autodesk.DesignScript.Geometry.Point.ByCoordinates@double,double,double", + "Id": "91a4e9ef78a4421caefe814beae6080e", + "Inputs": [ + { + "Id": "8d28500e0bd24cffb44958c7b95ef073", + "Name": "x", + "Description": "X coordinate\n\ndouble\nDefault value : 0", + "UsingDefaultValue": true, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + }, + { + "Id": "a48eb950de0d4598a6faf57db74270f1", + "Name": "y", + "Description": "Y coordinate\n\ndouble\nDefault value : 0", + "UsingDefaultValue": true, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + }, + { + "Id": "37efacaec17a41c9a95973ff91deaf78", + "Name": "z", + "Description": "Z coordinate\n\ndouble\nDefault value : 0", + "UsingDefaultValue": true, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Outputs": [ + { + "Id": "a55676ee87c64f469a7bcf4eaa495f57", + "Name": "Point", + "Description": "Point created by coordinates", + "UsingDefaultValue": false, + "Level": 2, + "UseLevels": false, + "KeepListStructure": false + } + ], + "Replication": "Auto", + "Description": "Form a Point given 3 cartesian coordinates\n\nPoint.ByCoordinates (x: double = 0, y: double = 0, z: double = 0): Point" + } + ], + "Connectors": [ + { + "Start": "a55676ee87c64f469a7bcf4eaa495f57", + "End": "72f6cbed9a1a470e8db57a6b523ed94f", + "Id": "759343676288412e837bfea54a48793a", + "IsHidden": "False" + } + ], + "Dependencies": [], + "NodeLibraryDependencies": [], + "Thumbnail": "", + "GraphDocumentationURL": null, + "ExtensionWorkspaceData": [ + { + "ExtensionGuid": "28992e1d-abb9-417f-8b1b-05e053bee670", + "Name": "Properties", + "Version": "2.17", + "Data": {} + } + ], + "Author": "", + "Linting": { + "activeLinter": "None", + "activeLinterId": "7b75fb44-43fd-4631-a878-29f4d5d8399a", + "warningCount": 0, + "errorCount": 0 + }, + "Bindings": [], + "View": { + "Dynamo": { + "ScaleFactor": 1.0, + "HasRunWithoutCrash": true, + "IsVisibleInDynamoLibrary": true, + "Version": "2.17.0.2986", + "RunType": "Automatic", + "RunPeriod": "1000" + }, + "Camera": { + "Name": "_Background Preview", + "EyeX": -17.0, + "EyeY": 24.0, + "EyeZ": 50.0, + "LookX": 12.0, + "LookY": -13.0, + "LookZ": -58.0, + "UpX": 0.0, + "UpY": 1.0, + "UpZ": 0.0 + }, + "ConnectorPins": [], + "NodeViews": [ + { + "Name": "Watch 3D", + "ShowGeometry": true, + "Id": "c59ed620269a44d68540edba42d7fd04", + "IsSetAsInput": false, + "IsSetAsOutput": false, + "Excluded": false, + "X": 615.5, + "Y": 235.5 + }, + { + "Name": "Point.ByCoordinates", + "ShowGeometry": false, + "Id": "91a4e9ef78a4421caefe814beae6080e", + "IsSetAsInput": false, + "IsSetAsOutput": false, + "Excluded": false, + "X": 317.5, + "Y": 220.0 + } + ], + "Annotations": [], + "X": 0.0, + "Y": 0.0, + "Zoom": 1.0 + } +} \ No newline at end of file From 4165db0d23427792c2e17c89e4b97e49b9929f0d Mon Sep 17 00:00:00 2001 From: Long Nguyen Date: Mon, 14 Nov 2022 21:54:30 +0700 Subject: [PATCH 15/21] Fixed wrong test geometry in dyn file --- ...ixWatch3dNodeViewModel_IgnoreIsVisible.dyn | 47 ++++++++----------- 1 file changed, 19 insertions(+), 28 deletions(-) diff --git a/test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn b/test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn index 462193b6a68..5eb45ad6e35 100644 --- a/test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn +++ b/test/core/visualization/HelixWatch3dNodeViewModel_IgnoreIsVisible.dyn @@ -56,31 +56,22 @@ { "ConcreteType": "Dynamo.Graph.Nodes.ZeroTouch.DSFunction, DynamoCore", "NodeType": "FunctionNode", - "FunctionSignature": "Autodesk.DesignScript.Geometry.Point.ByCoordinates@double,double,double", - "Id": "91a4e9ef78a4421caefe814beae6080e", + "FunctionSignature": "Autodesk.DesignScript.Geometry.Sphere.ByCenterPointRadius@Autodesk.DesignScript.Geometry.Point,double", + "Id": "294aa59e5bd84f2d9f8e66cc97246be8", "Inputs": [ { - "Id": "8d28500e0bd24cffb44958c7b95ef073", - "Name": "x", - "Description": "X coordinate\n\ndouble\nDefault value : 0", + "Id": "747fd3d3884343fa973395e5523814ab", + "Name": "centerPoint", + "Description": "Point\nDefault value : Autodesk.DesignScript.Geometry.Point.ByCoordinates(0, 0, 0)", "UsingDefaultValue": true, "Level": 2, "UseLevels": false, "KeepListStructure": false }, { - "Id": "a48eb950de0d4598a6faf57db74270f1", - "Name": "y", - "Description": "Y coordinate\n\ndouble\nDefault value : 0", - "UsingDefaultValue": true, - "Level": 2, - "UseLevels": false, - "KeepListStructure": false - }, - { - "Id": "37efacaec17a41c9a95973ff91deaf78", - "Name": "z", - "Description": "Z coordinate\n\ndouble\nDefault value : 0", + "Id": "f93f1209d1834f5e81291b1f21345283", + "Name": "radius", + "Description": "double\nDefault value : 1", "UsingDefaultValue": true, "Level": 2, "UseLevels": false, @@ -89,9 +80,9 @@ ], "Outputs": [ { - "Id": "a55676ee87c64f469a7bcf4eaa495f57", - "Name": "Point", - "Description": "Point created by coordinates", + "Id": "5d3ada3ff31a43a3a5b4d3c973f920bf", + "Name": "Sphere", + "Description": "Sphere", "UsingDefaultValue": false, "Level": 2, "UseLevels": false, @@ -99,14 +90,14 @@ } ], "Replication": "Auto", - "Description": "Form a Point given 3 cartesian coordinates\n\nPoint.ByCoordinates (x: double = 0, y: double = 0, z: double = 0): Point" + "Description": "Create a Solid Sphere cetered at the input Point, with given radius.\n\nSphere.ByCenterPointRadius (centerPoint: Point = Autodesk.DesignScript.Geometry.Point.ByCoordinates(0, 0, 0), radius: double = 1): Sphere" } ], "Connectors": [ { - "Start": "a55676ee87c64f469a7bcf4eaa495f57", + "Start": "5d3ada3ff31a43a3a5b4d3c973f920bf", "End": "72f6cbed9a1a470e8db57a6b523ed94f", - "Id": "759343676288412e837bfea54a48793a", + "Id": "eb57bb3f94d24dc18363a9967eaf847f", "IsHidden": "False" } ], @@ -164,14 +155,14 @@ "Y": 235.5 }, { - "Name": "Point.ByCoordinates", - "ShowGeometry": false, - "Id": "91a4e9ef78a4421caefe814beae6080e", + "Name": "Sphere.ByCenterPointRadius", + "ShowGeometry": true, + "Id": "294aa59e5bd84f2d9f8e66cc97246be8", "IsSetAsInput": false, "IsSetAsOutput": false, "Excluded": false, - "X": 317.5, - "Y": 220.0 + "X": 249.5, + "Y": 218.0 } ], "Annotations": [], From 5d64c4e8993e1e4fe4b17eb89636624ea27cd15f Mon Sep 17 00:00:00 2001 From: Long Nguyen Date: Mon, 14 Nov 2022 21:57:00 +0700 Subject: [PATCH 16/21] Added another Assert to the IgnoreIsVisible test --- .../@bcoe/v8-coverage/dist/lib/CHANGELOG.md | 250 ++++++ .../@bcoe/v8-coverage/dist/lib/LICENSE.md | 21 + .../@bcoe/v8-coverage/dist/lib/README.md | 11 + .../@bcoe/v8-coverage/dist/lib/ascii.d.ts | 12 + .../@bcoe/v8-coverage/dist/lib/ascii.js | 136 +++ .../@bcoe/v8-coverage/dist/lib/ascii.mjs | 130 +++ .../@bcoe/v8-coverage/dist/lib/clone.d.ts | 29 + .../@bcoe/v8-coverage/dist/lib/clone.js | 70 ++ .../@bcoe/v8-coverage/dist/lib/clone.mjs | 64 ++ .../@bcoe/v8-coverage/dist/lib/compare.d.ts | 21 + .../@bcoe/v8-coverage/dist/lib/compare.js | 46 + .../@bcoe/v8-coverage/dist/lib/compare.mjs | 41 + .../@bcoe/v8-coverage/dist/lib/index.d.ts | 6 + .../@bcoe/v8-coverage/dist/lib/index.js | 24 + .../@bcoe/v8-coverage/dist/lib/index.mjs | 7 + .../@bcoe/v8-coverage/dist/lib/merge.d.ts | 39 + .../@bcoe/v8-coverage/dist/lib/merge.js | 302 +++++++ .../@bcoe/v8-coverage/dist/lib/merge.mjs | 297 +++++++ .../@bcoe/v8-coverage/dist/lib/normalize.d.ts | 53 ++ .../@bcoe/v8-coverage/dist/lib/normalize.js | 87 ++ .../@bcoe/v8-coverage/dist/lib/normalize.mjs | 79 ++ .../@bcoe/v8-coverage/dist/lib/package.json | 44 + .../v8-coverage/dist/lib/range-tree.d.ts | 24 + .../@bcoe/v8-coverage/dist/lib/range-tree.js | 139 +++ .../@bcoe/v8-coverage/dist/lib/range-tree.mjs | 136 +++ .../@bcoe/v8-coverage/dist/lib/tsconfig.json | 62 ++ .../@bcoe/v8-coverage/dist/lib/types.d.ts | 22 + .../@bcoe/v8-coverage/dist/lib/types.js | 4 + .../@bcoe/v8-coverage/dist/lib/types.mjs | 3 + .../@bcoe/v8-coverage/src/lib/ascii.ts | 146 +++ .../@bcoe/v8-coverage/src/lib/clone.ts | 70 ++ .../@bcoe/v8-coverage/src/lib/compare.ts | 40 + .../@bcoe/v8-coverage/src/lib/index.ts | 6 + .../@bcoe/v8-coverage/src/lib/merge.ts | 343 +++++++ .../@bcoe/v8-coverage/src/lib/normalize.ts | 84 ++ .../@bcoe/v8-coverage/src/lib/range-tree.ts | 156 ++++ .../@bcoe/v8-coverage/src/lib/types.ts | 26 + .../@bcoe/v8-coverage/src/test/merge.spec.ts | 280 ++++++ .../@jest/core/build/assets/jest_logo.png | Bin 0 -> 3157 bytes .../@jest/core/build/cli/index.d.ts | 12 + .../@jest/core/build/cli/index.js | 399 +++++++++ .../core/build/lib/activeFiltersMessage.d.ts | 9 + .../core/build/lib/activeFiltersMessage.js | 54 ++ .../@jest/core/build/lib/createContext.d.ts | 10 + .../@jest/core/build/lib/createContext.js | 35 + .../build/lib/handleDeprecationWarnings.d.ts | 8 + .../build/lib/handleDeprecationWarnings.js | 72 ++ .../@jest/core/build/lib/isValidPath.d.ts | 8 + .../@jest/core/build/lib/isValidPath.js | 29 + .../core/build/lib/logDebugMessages.d.ts | 9 + .../@jest/core/build/lib/logDebugMessages.js | 23 + .../core/build/lib/updateGlobalConfig.d.ts | 11 + .../core/build/lib/updateGlobalConfig.js | 121 +++ .../core/build/lib/watchPluginsHelpers.d.ts | 10 + .../core/build/lib/watchPluginsHelpers.js | 62 ++ .../build/plugins/FailedTestsInteractive.d.ts | 17 + .../build/plugins/FailedTestsInteractive.js | 135 +++ .../@jest/core/build/plugins/Quit.d.ts | 18 + .../@jest/core/build/plugins/Quit.js | 60 ++ .../core/build/plugins/TestNamePattern.d.ts | 21 + .../core/build/plugins/TestNamePattern.js | 91 ++ .../core/build/plugins/TestPathPattern.d.ts | 21 + .../core/build/plugins/TestPathPattern.js | 91 ++ .../core/build/plugins/UpdateSnapshots.d.ts | 21 + .../core/build/plugins/UpdateSnapshots.js | 70 ++ .../plugins/UpdateSnapshotsInteractive.d.ts | 20 + .../plugins/UpdateSnapshotsInteractive.js | 138 +++ .../core/node_modules/ansi-styles/index.d.ts | 345 +++++++ .../core/node_modules/ansi-styles/index.js | 163 ++++ .../core/node_modules/ansi-styles/license | 9 + .../node_modules/ansi-styles/package.json | 56 ++ .../core/node_modules/ansi-styles/readme.md | 152 ++++ .../@jest/core/node_modules/chalk/index.d.ts | 415 +++++++++ .../@jest/core/node_modules/chalk/license | 9 + .../core/node_modules/chalk/package.json | 68 ++ .../@jest/core/node_modules/chalk/readme.md | 341 +++++++ .../node_modules/color-convert/CHANGELOG.md | 54 ++ .../core/node_modules/color-convert/LICENSE | 21 + .../core/node_modules/color-convert/README.md | 68 ++ .../node_modules/color-convert/conversions.js | 839 ++++++++++++++++++ .../core/node_modules/color-convert/index.js | 81 ++ .../node_modules/color-convert/package.json | 48 + .../core/node_modules/color-convert/route.js | 97 ++ .../core/node_modules/color-name/LICENSE | 8 + .../core/node_modules/color-name/README.md | 11 + .../core/node_modules/color-name/index.js | 152 ++++ .../core/node_modules/color-name/package.json | 28 + .../core/node_modules/has-flag/index.d.ts | 39 + .../@jest/core/node_modules/has-flag/index.js | 8 + .../@jest/core/node_modules/has-flag/license | 9 + .../core/node_modules/has-flag/package.json | 46 + .../core/node_modules/has-flag/readme.md | 89 ++ .../node_modules/supports-color/browser.js | 5 + .../core/node_modules/supports-color/index.js | 135 +++ .../core/node_modules/supports-color/license | 9 + .../node_modules/supports-color/package.json | 53 ++ .../node_modules/supports-color/readme.md | 76 ++ .../@jest/types/node_modules/chalk/index.d.ts | 415 +++++++++ .../@jest/types/node_modules/chalk/license | 9 + .../types/node_modules/chalk/package.json | 68 ++ .../@jest/types/node_modules/chalk/readme.md | 341 +++++++ .../types/node_modules/has-flag/index.d.ts | 39 + .../types/node_modules/has-flag/index.js | 8 + .../@jest/types/node_modules/has-flag/license | 9 + .../y18n/build/lib/platform-shims/node.js | 19 + .../HelixWatch3DViewModelTests.cs | 3 +- 106 files changed, 9229 insertions(+), 1 deletion(-) create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/CHANGELOG.md create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/LICENSE.md create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/README.md create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/package.json create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/tsconfig.json create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.d.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.js create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.mjs create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/ascii.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/clone.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/compare.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/index.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/merge.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/normalize.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/range-tree.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/types.ts create mode 100644 src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/test/merge.spec.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/assets/jest_logo.png create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/cli/index.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/cli/index.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/license create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/package.json create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/readme.md create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/index.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/license create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/package.json create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/readme.md create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-convert/CHANGELOG.md create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-convert/LICENSE create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-convert/README.md create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-convert/conversions.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-convert/index.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-convert/package.json create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-convert/route.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-name/LICENSE create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-name/README.md create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-name/index.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/color-name/package.json create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/has-flag/index.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/has-flag/index.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/has-flag/license create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/has-flag/package.json create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/has-flag/readme.md create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/supports-color/browser.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/supports-color/index.js create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/supports-color/license create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/supports-color/package.json create mode 100644 src/DynamoSandbox/node_modules/@jest/core/node_modules/supports-color/readme.md create mode 100644 src/DynamoSandbox/node_modules/@jest/types/node_modules/chalk/index.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/types/node_modules/chalk/license create mode 100644 src/DynamoSandbox/node_modules/@jest/types/node_modules/chalk/package.json create mode 100644 src/DynamoSandbox/node_modules/@jest/types/node_modules/chalk/readme.md create mode 100644 src/DynamoSandbox/node_modules/@jest/types/node_modules/has-flag/index.d.ts create mode 100644 src/DynamoSandbox/node_modules/@jest/types/node_modules/has-flag/index.js create mode 100644 src/DynamoSandbox/node_modules/@jest/types/node_modules/has-flag/license create mode 100644 src/DynamoSandbox/node_modules/y18n/build/lib/platform-shims/node.js diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/CHANGELOG.md b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/CHANGELOG.md new file mode 100644 index 00000000000..7300dec3f3a --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/CHANGELOG.md @@ -0,0 +1,250 @@ +## Next + +- **[Breaking change]** Replace `OutModules` enum by custom compiler option `mjsModule`. +- **[Breaking change]** Drop support for Pug, Sass, Angular & Webpack. +- **[Feature]** Expose custom registries for each target. +- **[Feature]** Add `dist.tscOptions` for `lib` target to override options for + distribution builds. +- **[Feature]** Native ESM tests with mocha. +- **[Fix]** Disable deprecated TsLint rules from the default config +- **[Fix]** Remove use of experimental `fs/promises` module. +- **[Internal]** Fix continuous deployment script (stop confusing PRs to master + with push to master) +- **[Internal]** Update dependencies +- **[Internal]** Fix deprecated Mocha types. + +## 0.17.1 (2017-05-03) + +- **[Fix]** Update dependencies, remove `std/esm` warning. + +## 0.17.0 (2017-04-22) + +- **[Breaking change]** Update dependencies. Use `esm` instead of `@std/esm`, update Typescript to `2.8.3`. +- **[Fix]** Fix Node processes spawn on Windows (Mocha, Nyc) + +## 0.16.2 (2017-02-07) + +- **[Fix]** Fix Typedoc generation: use `tsconfig.json` generated for the lib. +- **[Fix]** Write source map for `.mjs` files +- **[Fix]** Copy sources to `_src` when publishing a lib (#87). +- **[Internal]** Restore continuous deployment of documentation. + +## 0.16.1 (2017-01-20) + +- **[Feature]** Support `mocha` tests on `.mjs` files (using `@std/esm`). Enabled by default + if `outModules` is configured to emit `.mjs`. **You currently need to add + `"@std/esm": {"esm": "cjs"}` to your `package.json`.** + +## 0.16.0 (2017-01-09) + +- **[Breaking change]** Enable `allowSyntheticDefaultImports` and `esModuleInterop` by default +- **[Fix]** Allow deep module imports in default Tslint rules +- **[Fix]** Drop dependency on deprecated `gulp-util` +- **[Internal]** Replace most custom typings by types from `@types` + +## 0.15.8 (2017-12-05) + +- **[Fix]** Exit with non-zero code if command tested with coverage fails +- **[Fix]** Solve duplicated error message when using the `run` mocha task. +- **[Fix]** Exit with non-zero code when building scripts fails. + +## 0.15.7 (2017-11-29) + +- **[Feature]** Add `coverage` task to `mocha` target, use it for the default task + +## 0.15.6 (2017-11-29) + +- **[Fix]** Fix path to source in source maps. +- **[Fix]** Disable `number-literal-format` in default Tslint rules. It enforced uppercase for hex. +- **[Internal]** Enable integration with Greenkeeper. +- **[Internal]** Enable integration with Codecov +- **[Internal]** Enable code coverage + +## 0.15.5 (2017-11-10) + +- **[Feature]** Enable the following TsLint rules: `no-duplicate-switch-case`, `no-implicit-dependencies`, + `no-return-await` +- **[Internal]** Update self-dependency `0.15.4`, this restores the README on _npm_ +- **[Internal]** Add homepage and author fields to package.json + +## 0.15.4 (2017-11-10) + +- **[Fix]** Add support for custom additional copy for distribution builds. [#49](https://github.com/demurgos/turbo-gulp/issues/49) +- **[Internal]** Update self-dependency to `turbo-gulp` +- **[Internal]** Add link to license in `README.md` + +## 0.15.3 (2017-11-09) + +**Rename to `turbo-gulp`**. This package was previously named `demurgos-web-build-tools`. +This version is fully compatible: you can just change the name of your dependency. + +## 0.15.2 (2017-11-09) + +**The package is prepared to be renamed `turbo-gulp`.** +This is the last version released as `demurgos-web-build-tools`. + +- **[Feature]** Add support for watch mode for library targets. +- **[Fix]** Disable experimental support for `*.mjs` by default. +- **[Fix]** Do not emit duplicate TS errors + +## 0.15.1 (2017-10-19) + +- **[Feature]** Add experimental support for `*.mjs` files +- **[Fix]** Fix support of releases from Continuous Deployment using Travis. + +## 0.15.0 (2017-10-18) + +- **[Fix]** Add error handling for git deployment. +- **[Internal]** Enable continuous deployment of the `master` branch. + +## 0.15.0-beta.11 (2017-08-29) + +- **[Feature]** Add `LibTarget.dist.copySrc` option to disable copy of source files to the dist directory. + This allows to prevent issues with missing custom typings. +- **[Fix]** Mark `deploy` property of `LibTarget.typedoc` as optional. +- **[Internal]** Update self-dependency to `v0.15.0-beta.10`. + +## 0.15.0-beta.10 (2017-08-28) + +- **[Breaking]** Update Tslint rules to use `tslint@5.7.0`. +- **[Fix]** Set `allowJs` to false in default TSC options. +- **[Fix]** Do not pipe output of git commands to stdout. +- **[Internal]** Update self-dependency to `v0.15.0-beta.9`. + +## 0.15.0-beta.9 (2017-08-28) + +- **[Breaking]** Drop old-style `test` target. +- **[Breaking]** Drop old-style `node` target. +- **[Feature]** Add `mocha` target to run tests in `spec.ts` files. +- **[Feature]** Add `node` target to build and run top-level Node applications. +- **[Feature]** Provide `generateNodeTasks`, `generateLibTasks` and `generateMochaTasks` functions. + They create the tasks but do not register them. +- **[Fix]** Run `clean` before `dist`, if defined. +- **[Fix]** Run `dist` before `publish`. + +## 0.15.0-beta.8 (2017-08-26) + +- **[Fix]** Remove auth token and registry options for `:dist:publish`. It is better served + by configuring the environment appropriately. + +## 0.15.0-beta.7 (2017-08-26) + +- **[Feature]** Add `clean` task to `lib` targets. +- **[Fix]** Ensure that `gitHead` is defined when publishing a package to npm. + +## 0.15.0-beta.6 (2017-08-22) + +- **[Feature]** Add support for Typedoc deployment to a remote git branch (such as `gh-pages`) +- **[Feature]** Add support for `copy` tasks in new library target. +- **[Fix]** Resolve absolute paths when compiling scripts with custom typings. + +## 0.15.0-beta.5 (2017-08-14) + +- **[Fix]** Fix package entry for the main module. + +## 0.15.0-beta.4 (2017-08-14) + +- **[Breaking]** Drop ES5 build exposed to browsers with the `browser` field in `package.json`. +- **[Feature]** Introduce first new-style target (`LibTarget`). it supports typedoc generation, dev builds and + simple distribution. + +## 0.15.0-beta.3 (2017-08-11) + +- **[Breaking]** Update default lib target to use target-specific `srcDir`. +- **[Feature]** Allow to complete `srcDir` in target. +- **[Feature]** Add experimental library distribution supporting deep requires. + +## 0.15.0-beta.2 (2017-08-10) + +- **[Fix]** Default to CommonJS for project tsconfig.json +- **[Fix]** Add Typescript configuration for default project. +- **[Internal]** Update self-dependency to `0.15.0-beta.1`. + +## 0.15.0-beta.1 (2017-08-09) + +- **[Feature]** Support typed TSLint rules. +- **[Internal]** Update gulpfile.ts to use build tools `0.15.0-beta.0`. +- **[Fix]** Fix regressions caused by `0.15.0-beta.0` (missing type definition). + +## 0.15.0-beta.0 (2017-08-09) + +- **[Breaking]** Expose option interfaces directly in the main module instead of the `config` namespace. +- **[Breaking]** Rename `DEFAULT_PROJECT_OPTIONS` to `DEFAULT_PROJECT`. +- **[Feature]** Emit project-wide `tsconfig.json`. +- **[Internal]** Convert gulpfile to Typescript, use `ts-node` to run it. +- **[Internal]** Update dependencies + +## 0.14.3 (2017-07-16) + +- **[Feature]** Add `:lint:fix` project task to fix some lint errors. + +## 0.14.2 (2017-07-10) + +- **[Internal]** Update dependencies: add `package-lock.json` and update `tslint`. + +## 0.14.1 (2017-06-17) + +- **[Internal]** Update dependencies. +- **[Internal]** Drop dependency on _Bluebird_. +- **[Internal]** Drop dependency on _typings_. + +## 0.14.0 (2017-05-10) + +- **[Breaking]** Enforce trailing commas by default for multiline objects +- **[Feature]** Allow bump from either `master` or a branch with the same name as the tag (exampel: `v1.2.3`) +- **[Feature]** Support TSLint 8, allow to extend the default rules +- **[Patch]** Allow mergeable namespaces + +# 0.13.1 + +- **[Patch]** Allow namespaces in the default TS-Lint config + +# 0.13.0 + +- **[Breaking]** Major overhaul of the angular target. The server build no longer depends on the client. +- **[Breaking]** Update to `gulp@4` (from `gulp@3`) +- **[Breaking]** Update to `tslint@7` (from `tslint@6`), add stricter default rules +- **[Breaking]** Update signature of targetGenerators and project tasks: it only uses + `ProjectOptions` and `Target` now, the additional options are embedded in those two objects. +- **[Breaking]** Remove `:install`, `:instal:npm` and `:install:typings`. Use the `prepare` script in + your `package.json` file instead. +- Add `:tslint.json` project task to generate configuration for `tslint` +- Add first class support for processing of `pug` and `sass` files, similar to `copy` +- Implement end-to-end tests +- Enable `emitDecoratorMetadata` in default typescript options. +- Allow configuration of `:lint` with the `tslintOptions` property of the project configuration. +- Add `:watch` tasks for incremental builds. + +# 0.12.3 + +- Support `templateUrl` and `styleUrls` in angular modules. + +# 0.12.2 + +- Add `:build:copy` task. It copies user-defined files. + +# 0.12.1 + +- Fix `:watch` task. + +# 0.12.0 + +- **[Breaking]**: Change naming convention for tasks. The names primary part is + the target, then the action (`lib:build` instead of `build:lib`) to group + the tasks per target. +- **[Breaking]**: Use `typeRoots` instead of `definitions` in configuration to + specify Typescript definition files. +- Generate `tsconfig.json` file (mainly for editors) +- Implement the `test` target to run unit-tests with `mocha`. + +# 0.11.2 + +- Target `angular`: Add `build::assets:sass` for `.scss` files (Sassy CSS) + +# 0.11.1 + +- Rename project to `web-build-tools` (`demurgos-web-build-tools` on _npm_) +- Target `angular`: Add `build::assets`, `build::pug` and `build::static`. +- Update `gulp-typescript`: solve error message during compilation +- Targets `node` and `angular`: `build::scripts` now include in-lined source maps +- Target `node`: `watch:` to support incremental builds diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/LICENSE.md b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/LICENSE.md new file mode 100644 index 00000000000..d588b5c321e --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/LICENSE.md @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright © 2015-2017 Charles Samborski + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/README.md b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/README.md new file mode 100644 index 00000000000..eea761b9dfe --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/README.md @@ -0,0 +1,11 @@ +# V8 Coverage + +[![npm](https://img.shields.io/npm/v/@c88/v8-coverage.svg?maxAge=2592000)](https://www.npmjs.com/package/@c88/v8-coverage) +[![GitHub repository](https://img.shields.io/badge/Github-demurgos%2Fv8--coverage-blue.svg)](https://github.com/demurgos/v8-coverage) +[![Build status (Travis)](https://img.shields.io/travis/demurgos/v8-coverage/master.svg?maxAge=2592000)](https://travis-ci.org/demurgos/v8-coverage) +[![Build status (AppVeyor)](https://ci.appveyor.com/api/projects/status/qgcbdffyb9e09d0e?svg=true)](https://ci.appveyor.com/project/demurgos/v8-coverage) +[![Codecov](https://codecov.io/gh/demurgos/v8-coverage/branch/master/graph/badge.svg)](https://codecov.io/gh/demurgos/v8-coverage) + +## License + +[MIT License](./LICENSE.md) diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.d.ts new file mode 100644 index 00000000000..a56836df66d --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.d.ts @@ -0,0 +1,12 @@ +import { RangeCov } from "./types"; +interface ReadonlyRangeTree { + readonly start: number; + readonly end: number; + readonly count: number; + readonly children: ReadonlyRangeTree[]; +} +export declare function emitForest(trees: ReadonlyArray): string; +export declare function emitForestLines(trees: ReadonlyArray): string[]; +export declare function parseFunctionRanges(text: string, offsetMap: Map): RangeCov[]; +export declare function parseOffsets(text: string): Map; +export {}; diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.js new file mode 100644 index 00000000000..f26caad9849 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.js @@ -0,0 +1,136 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const compare_1 = require("./compare"); +function emitForest(trees) { + return emitForestLines(trees).join("\n"); +} +exports.emitForest = emitForest; +function emitForestLines(trees) { + const colMap = getColMap(trees); + const header = emitOffsets(colMap); + return [header, ...trees.map(tree => emitTree(tree, colMap).join("\n"))]; +} +exports.emitForestLines = emitForestLines; +function getColMap(trees) { + const eventSet = new Set(); + for (const tree of trees) { + const stack = [tree]; + while (stack.length > 0) { + const cur = stack.pop(); + eventSet.add(cur.start); + eventSet.add(cur.end); + for (const child of cur.children) { + stack.push(child); + } + } + } + const events = [...eventSet]; + events.sort((a, b) => a - b); + let maxDigits = 1; + for (const event of events) { + maxDigits = Math.max(maxDigits, event.toString(10).length); + } + const colWidth = maxDigits + 3; + const colMap = new Map(); + for (const [i, event] of events.entries()) { + colMap.set(event, i * colWidth); + } + return colMap; +} +function emitTree(tree, colMap) { + const layers = []; + let nextLayer = [tree]; + while (nextLayer.length > 0) { + const layer = nextLayer; + layers.push(layer); + nextLayer = []; + for (const node of layer) { + for (const child of node.children) { + nextLayer.push(child); + } + } + } + return layers.map(layer => emitTreeLayer(layer, colMap)); +} +function parseFunctionRanges(text, offsetMap) { + const result = []; + for (const line of text.split("\n")) { + for (const range of parseTreeLayer(line, offsetMap)) { + result.push(range); + } + } + result.sort(compare_1.compareRangeCovs); + return result; +} +exports.parseFunctionRanges = parseFunctionRanges; +/** + * + * @param layer Sorted list of disjoint trees. + * @param colMap + */ +function emitTreeLayer(layer, colMap) { + const line = []; + let curIdx = 0; + for (const { start, end, count } of layer) { + const startIdx = colMap.get(start); + const endIdx = colMap.get(end); + if (startIdx > curIdx) { + line.push(" ".repeat(startIdx - curIdx)); + } + line.push(emitRange(count, endIdx - startIdx)); + curIdx = endIdx; + } + return line.join(""); +} +function parseTreeLayer(text, offsetMap) { + const result = []; + const regex = /\[(\d+)-*\)/gs; + while (true) { + const match = regex.exec(text); + if (match === null) { + break; + } + const startIdx = match.index; + const endIdx = startIdx + match[0].length; + const count = parseInt(match[1], 10); + const startOffset = offsetMap.get(startIdx); + const endOffset = offsetMap.get(endIdx); + if (startOffset === undefined || endOffset === undefined) { + throw new Error(`Invalid offsets for: ${JSON.stringify(text)}`); + } + result.push({ startOffset, endOffset, count }); + } + return result; +} +function emitRange(count, len) { + const rangeStart = `[${count.toString(10)}`; + const rangeEnd = ")"; + const hyphensLen = len - (rangeStart.length + rangeEnd.length); + const hyphens = "-".repeat(Math.max(0, hyphensLen)); + return `${rangeStart}${hyphens}${rangeEnd}`; +} +function emitOffsets(colMap) { + let line = ""; + for (const [event, col] of colMap) { + if (line.length < col) { + line += " ".repeat(col - line.length); + } + line += event.toString(10); + } + return line; +} +function parseOffsets(text) { + const result = new Map(); + const regex = /\d+/gs; + while (true) { + const match = regex.exec(text); + if (match === null) { + break; + } + result.set(match.index, parseInt(match[0], 10)); + } + return result; +} +exports.parseOffsets = parseOffsets; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/ascii.ts"],"names":[],"mappings":"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","file":"ascii.js","sourcesContent":["import { compareRangeCovs } from \"./compare\";\nimport { RangeCov } from \"./types\";\n\ninterface ReadonlyRangeTree {\n  readonly start: number;\n  readonly end: number;\n  readonly count: number;\n  readonly children: ReadonlyRangeTree[];\n}\n\nexport function emitForest(trees: ReadonlyArray<ReadonlyRangeTree>): string {\n  return emitForestLines(trees).join(\"\\n\");\n}\n\nexport function emitForestLines(trees: ReadonlyArray<ReadonlyRangeTree>): string[] {\n  const colMap: Map<number, number> = getColMap(trees);\n  const header: string = emitOffsets(colMap);\n  return [header, ...trees.map(tree => emitTree(tree, colMap).join(\"\\n\"))];\n}\n\nfunction getColMap(trees: Iterable<ReadonlyRangeTree>): Map<number, number> {\n  const eventSet: Set<number> = new Set();\n  for (const tree of trees) {\n    const stack: ReadonlyRangeTree[] = [tree];\n    while (stack.length > 0) {\n      const cur: ReadonlyRangeTree = stack.pop()!;\n      eventSet.add(cur.start);\n      eventSet.add(cur.end);\n      for (const child of cur.children) {\n        stack.push(child);\n      }\n    }\n  }\n  const events: number[] = [...eventSet];\n  events.sort((a, b) => a - b);\n  let maxDigits: number = 1;\n  for (const event of events) {\n    maxDigits = Math.max(maxDigits, event.toString(10).length);\n  }\n  const colWidth: number = maxDigits + 3;\n  const colMap: Map<number, number> = new Map();\n  for (const [i, event] of events.entries()) {\n    colMap.set(event, i * colWidth);\n  }\n  return colMap;\n}\n\nfunction emitTree(tree: ReadonlyRangeTree, colMap: Map<number, number>): string[] {\n  const layers: ReadonlyRangeTree[][] = [];\n  let nextLayer: ReadonlyRangeTree[] = [tree];\n  while (nextLayer.length > 0) {\n    const layer: ReadonlyRangeTree[] = nextLayer;\n    layers.push(layer);\n    nextLayer = [];\n    for (const node of layer) {\n      for (const child of node.children) {\n        nextLayer.push(child);\n      }\n    }\n  }\n  return layers.map(layer => emitTreeLayer(layer, colMap));\n}\n\nexport function parseFunctionRanges(text: string, offsetMap: Map<number, number>): RangeCov[] {\n  const result: RangeCov[] = [];\n  for (const line of text.split(\"\\n\")) {\n    for (const range of parseTreeLayer(line, offsetMap)) {\n      result.push(range);\n    }\n  }\n  result.sort(compareRangeCovs);\n  return result;\n}\n\n/**\n *\n * @param layer Sorted list of disjoint trees.\n * @param colMap\n */\nfunction emitTreeLayer(layer: ReadonlyRangeTree[], colMap: Map<number, number>): string {\n  const line: string[] = [];\n  let curIdx: number = 0;\n  for (const {start, end, count} of layer) {\n    const startIdx: number = colMap.get(start)!;\n    const endIdx: number = colMap.get(end)!;\n    if (startIdx > curIdx) {\n      line.push(\" \".repeat(startIdx - curIdx));\n    }\n    line.push(emitRange(count, endIdx - startIdx));\n    curIdx = endIdx;\n  }\n  return line.join(\"\");\n}\n\nfunction parseTreeLayer(text: string, offsetMap: Map<number, number>): RangeCov[] {\n  const result: RangeCov[] = [];\n  const regex: RegExp = /\\[(\\d+)-*\\)/gs;\n  while (true) {\n    const match: RegExpMatchArray | null = regex.exec(text);\n    if (match === null) {\n      break;\n    }\n    const startIdx: number = match.index!;\n    const endIdx: number = startIdx + match[0].length;\n    const count: number = parseInt(match[1], 10);\n    const startOffset: number | undefined = offsetMap.get(startIdx);\n    const endOffset: number | undefined = offsetMap.get(endIdx);\n    if (startOffset === undefined || endOffset === undefined) {\n      throw new Error(`Invalid offsets for: ${JSON.stringify(text)}`);\n    }\n    result.push({startOffset, endOffset, count});\n  }\n  return result;\n}\n\nfunction emitRange(count: number, len: number): string {\n  const rangeStart: string = `[${count.toString(10)}`;\n  const rangeEnd: string = \")\";\n  const hyphensLen: number = len - (rangeStart.length + rangeEnd.length);\n  const hyphens: string = \"-\".repeat(Math.max(0, hyphensLen));\n  return `${rangeStart}${hyphens}${rangeEnd}`;\n}\n\nfunction emitOffsets(colMap: Map<number, number>): string {\n  let line: string = \"\";\n  for (const [event, col] of colMap) {\n    if (line.length < col) {\n      line += \" \".repeat(col - line.length);\n    }\n    line += event.toString(10);\n  }\n  return line;\n}\n\nexport function parseOffsets(text: string): Map<number, number> {\n  const result: Map<number, number> = new Map();\n  const regex: RegExp = /\\d+/gs;\n  while (true) {\n    const match: RegExpExecArray | null = regex.exec(text);\n    if (match === null) {\n      break;\n    }\n    result.set(match.index, parseInt(match[0], 10));\n  }\n  return result;\n}\n"],"sourceRoot":""} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.mjs new file mode 100644 index 00000000000..050b3190633 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/ascii.mjs @@ -0,0 +1,130 @@ +import { compareRangeCovs } from "./compare"; +export function emitForest(trees) { + return emitForestLines(trees).join("\n"); +} +export function emitForestLines(trees) { + const colMap = getColMap(trees); + const header = emitOffsets(colMap); + return [header, ...trees.map(tree => emitTree(tree, colMap).join("\n"))]; +} +function getColMap(trees) { + const eventSet = new Set(); + for (const tree of trees) { + const stack = [tree]; + while (stack.length > 0) { + const cur = stack.pop(); + eventSet.add(cur.start); + eventSet.add(cur.end); + for (const child of cur.children) { + stack.push(child); + } + } + } + const events = [...eventSet]; + events.sort((a, b) => a - b); + let maxDigits = 1; + for (const event of events) { + maxDigits = Math.max(maxDigits, event.toString(10).length); + } + const colWidth = maxDigits + 3; + const colMap = new Map(); + for (const [i, event] of events.entries()) { + colMap.set(event, i * colWidth); + } + return colMap; +} +function emitTree(tree, colMap) { + const layers = []; + let nextLayer = [tree]; + while (nextLayer.length > 0) { + const layer = nextLayer; + layers.push(layer); + nextLayer = []; + for (const node of layer) { + for (const child of node.children) { + nextLayer.push(child); + } + } + } + return layers.map(layer => emitTreeLayer(layer, colMap)); +} +export function parseFunctionRanges(text, offsetMap) { + const result = []; + for (const line of text.split("\n")) { + for (const range of parseTreeLayer(line, offsetMap)) { + result.push(range); + } + } + result.sort(compareRangeCovs); + return result; +} +/** + * + * @param layer Sorted list of disjoint trees. + * @param colMap + */ +function emitTreeLayer(layer, colMap) { + const line = []; + let curIdx = 0; + for (const { start, end, count } of layer) { + const startIdx = colMap.get(start); + const endIdx = colMap.get(end); + if (startIdx > curIdx) { + line.push(" ".repeat(startIdx - curIdx)); + } + line.push(emitRange(count, endIdx - startIdx)); + curIdx = endIdx; + } + return line.join(""); +} +function parseTreeLayer(text, offsetMap) { + const result = []; + const regex = /\[(\d+)-*\)/gs; + while (true) { + const match = regex.exec(text); + if (match === null) { + break; + } + const startIdx = match.index; + const endIdx = startIdx + match[0].length; + const count = parseInt(match[1], 10); + const startOffset = offsetMap.get(startIdx); + const endOffset = offsetMap.get(endIdx); + if (startOffset === undefined || endOffset === undefined) { + throw new Error(`Invalid offsets for: ${JSON.stringify(text)}`); + } + result.push({ startOffset, endOffset, count }); + } + return result; +} +function emitRange(count, len) { + const rangeStart = `[${count.toString(10)}`; + const rangeEnd = ")"; + const hyphensLen = len - (rangeStart.length + rangeEnd.length); + const hyphens = "-".repeat(Math.max(0, hyphensLen)); + return `${rangeStart}${hyphens}${rangeEnd}`; +} +function emitOffsets(colMap) { + let line = ""; + for (const [event, col] of colMap) { + if (line.length < col) { + line += " ".repeat(col - line.length); + } + line += event.toString(10); + } + return line; +} +export function parseOffsets(text) { + const result = new Map(); + const regex = /\d+/gs; + while (true) { + const match = regex.exec(text); + if (match === null) { + break; + } + result.set(match.index, parseInt(match[0], 10)); + } + return result; +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/ascii.ts"],"names":[],"mappings":"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","file":"ascii.js","sourcesContent":["import { compareRangeCovs } from \"./compare\";\nimport { RangeCov } from \"./types\";\n\ninterface ReadonlyRangeTree {\n  readonly start: number;\n  readonly end: number;\n  readonly count: number;\n  readonly children: ReadonlyRangeTree[];\n}\n\nexport function emitForest(trees: ReadonlyArray<ReadonlyRangeTree>): string {\n  return emitForestLines(trees).join(\"\\n\");\n}\n\nexport function emitForestLines(trees: ReadonlyArray<ReadonlyRangeTree>): string[] {\n  const colMap: Map<number, number> = getColMap(trees);\n  const header: string = emitOffsets(colMap);\n  return [header, ...trees.map(tree => emitTree(tree, colMap).join(\"\\n\"))];\n}\n\nfunction getColMap(trees: Iterable<ReadonlyRangeTree>): Map<number, number> {\n  const eventSet: Set<number> = new Set();\n  for (const tree of trees) {\n    const stack: ReadonlyRangeTree[] = [tree];\n    while (stack.length > 0) {\n      const cur: ReadonlyRangeTree = stack.pop()!;\n      eventSet.add(cur.start);\n      eventSet.add(cur.end);\n      for (const child of cur.children) {\n        stack.push(child);\n      }\n    }\n  }\n  const events: number[] = [...eventSet];\n  events.sort((a, b) => a - b);\n  let maxDigits: number = 1;\n  for (const event of events) {\n    maxDigits = Math.max(maxDigits, event.toString(10).length);\n  }\n  const colWidth: number = maxDigits + 3;\n  const colMap: Map<number, number> = new Map();\n  for (const [i, event] of events.entries()) {\n    colMap.set(event, i * colWidth);\n  }\n  return colMap;\n}\n\nfunction emitTree(tree: ReadonlyRangeTree, colMap: Map<number, number>): string[] {\n  const layers: ReadonlyRangeTree[][] = [];\n  let nextLayer: ReadonlyRangeTree[] = [tree];\n  while (nextLayer.length > 0) {\n    const layer: ReadonlyRangeTree[] = nextLayer;\n    layers.push(layer);\n    nextLayer = [];\n    for (const node of layer) {\n      for (const child of node.children) {\n        nextLayer.push(child);\n      }\n    }\n  }\n  return layers.map(layer => emitTreeLayer(layer, colMap));\n}\n\nexport function parseFunctionRanges(text: string, offsetMap: Map<number, number>): RangeCov[] {\n  const result: RangeCov[] = [];\n  for (const line of text.split(\"\\n\")) {\n    for (const range of parseTreeLayer(line, offsetMap)) {\n      result.push(range);\n    }\n  }\n  result.sort(compareRangeCovs);\n  return result;\n}\n\n/**\n *\n * @param layer Sorted list of disjoint trees.\n * @param colMap\n */\nfunction emitTreeLayer(layer: ReadonlyRangeTree[], colMap: Map<number, number>): string {\n  const line: string[] = [];\n  let curIdx: number = 0;\n  for (const {start, end, count} of layer) {\n    const startIdx: number = colMap.get(start)!;\n    const endIdx: number = colMap.get(end)!;\n    if (startIdx > curIdx) {\n      line.push(\" \".repeat(startIdx - curIdx));\n    }\n    line.push(emitRange(count, endIdx - startIdx));\n    curIdx = endIdx;\n  }\n  return line.join(\"\");\n}\n\nfunction parseTreeLayer(text: string, offsetMap: Map<number, number>): RangeCov[] {\n  const result: RangeCov[] = [];\n  const regex: RegExp = /\\[(\\d+)-*\\)/gs;\n  while (true) {\n    const match: RegExpMatchArray | null = regex.exec(text);\n    if (match === null) {\n      break;\n    }\n    const startIdx: number = match.index!;\n    const endIdx: number = startIdx + match[0].length;\n    const count: number = parseInt(match[1], 10);\n    const startOffset: number | undefined = offsetMap.get(startIdx);\n    const endOffset: number | undefined = offsetMap.get(endIdx);\n    if (startOffset === undefined || endOffset === undefined) {\n      throw new Error(`Invalid offsets for: ${JSON.stringify(text)}`);\n    }\n    result.push({startOffset, endOffset, count});\n  }\n  return result;\n}\n\nfunction emitRange(count: number, len: number): string {\n  const rangeStart: string = `[${count.toString(10)}`;\n  const rangeEnd: string = \")\";\n  const hyphensLen: number = len - (rangeStart.length + rangeEnd.length);\n  const hyphens: string = \"-\".repeat(Math.max(0, hyphensLen));\n  return `${rangeStart}${hyphens}${rangeEnd}`;\n}\n\nfunction emitOffsets(colMap: Map<number, number>): string {\n  let line: string = \"\";\n  for (const [event, col] of colMap) {\n    if (line.length < col) {\n      line += \" \".repeat(col - line.length);\n    }\n    line += event.toString(10);\n  }\n  return line;\n}\n\nexport function parseOffsets(text: string): Map<number, number> {\n  const result: Map<number, number> = new Map();\n  const regex: RegExp = /\\d+/gs;\n  while (true) {\n    const match: RegExpExecArray | null = regex.exec(text);\n    if (match === null) {\n      break;\n    }\n    result.set(match.index, parseInt(match[0], 10));\n  }\n  return result;\n}\n"],"sourceRoot":""} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.d.ts new file mode 100644 index 00000000000..a0820325ba0 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.d.ts @@ -0,0 +1,29 @@ +import { FunctionCov, ProcessCov, RangeCov, ScriptCov } from "./types"; +/** + * Creates a deep copy of a process coverage. + * + * @param processCov Process coverage to clone. + * @return Cloned process coverage. + */ +export declare function cloneProcessCov(processCov: Readonly): ProcessCov; +/** + * Creates a deep copy of a script coverage. + * + * @param scriptCov Script coverage to clone. + * @return Cloned script coverage. + */ +export declare function cloneScriptCov(scriptCov: Readonly): ScriptCov; +/** + * Creates a deep copy of a function coverage. + * + * @param functionCov Function coverage to clone. + * @return Cloned function coverage. + */ +export declare function cloneFunctionCov(functionCov: Readonly): FunctionCov; +/** + * Creates a deep copy of a function coverage. + * + * @param rangeCov Range coverage to clone. + * @return Cloned range coverage. + */ +export declare function cloneRangeCov(rangeCov: Readonly): RangeCov; diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.js new file mode 100644 index 00000000000..4e8a823dc6d --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.js @@ -0,0 +1,70 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Creates a deep copy of a process coverage. + * + * @param processCov Process coverage to clone. + * @return Cloned process coverage. + */ +function cloneProcessCov(processCov) { + const result = []; + for (const scriptCov of processCov.result) { + result.push(cloneScriptCov(scriptCov)); + } + return { + result, + }; +} +exports.cloneProcessCov = cloneProcessCov; +/** + * Creates a deep copy of a script coverage. + * + * @param scriptCov Script coverage to clone. + * @return Cloned script coverage. + */ +function cloneScriptCov(scriptCov) { + const functions = []; + for (const functionCov of scriptCov.functions) { + functions.push(cloneFunctionCov(functionCov)); + } + return { + scriptId: scriptCov.scriptId, + url: scriptCov.url, + functions, + }; +} +exports.cloneScriptCov = cloneScriptCov; +/** + * Creates a deep copy of a function coverage. + * + * @param functionCov Function coverage to clone. + * @return Cloned function coverage. + */ +function cloneFunctionCov(functionCov) { + const ranges = []; + for (const rangeCov of functionCov.ranges) { + ranges.push(cloneRangeCov(rangeCov)); + } + return { + functionName: functionCov.functionName, + ranges, + isBlockCoverage: functionCov.isBlockCoverage, + }; +} +exports.cloneFunctionCov = cloneFunctionCov; +/** + * Creates a deep copy of a function coverage. + * + * @param rangeCov Range coverage to clone. + * @return Cloned range coverage. + */ +function cloneRangeCov(rangeCov) { + return { + startOffset: rangeCov.startOffset, + endOffset: rangeCov.endOffset, + count: rangeCov.count, + }; +} +exports.cloneRangeCov = cloneRangeCov; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.mjs new file mode 100644 index 00000000000..87482d6b090 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/clone.mjs @@ -0,0 +1,64 @@ +/** + * Creates a deep copy of a process coverage. + * + * @param processCov Process coverage to clone. + * @return Cloned process coverage. + */ +export function cloneProcessCov(processCov) { + const result = []; + for (const scriptCov of processCov.result) { + result.push(cloneScriptCov(scriptCov)); + } + return { + result, + }; +} +/** + * Creates a deep copy of a script coverage. + * + * @param scriptCov Script coverage to clone. + * @return Cloned script coverage. + */ +export function cloneScriptCov(scriptCov) { + const functions = []; + for (const functionCov of scriptCov.functions) { + functions.push(cloneFunctionCov(functionCov)); + } + return { + scriptId: scriptCov.scriptId, + url: scriptCov.url, + functions, + }; +} +/** + * Creates a deep copy of a function coverage. + * + * @param functionCov Function coverage to clone. + * @return Cloned function coverage. + */ +export function cloneFunctionCov(functionCov) { + const ranges = []; + for (const rangeCov of functionCov.ranges) { + ranges.push(cloneRangeCov(rangeCov)); + } + return { + functionName: functionCov.functionName, + ranges, + isBlockCoverage: functionCov.isBlockCoverage, + }; +} +/** + * Creates a deep copy of a function coverage. + * + * @param rangeCov Range coverage to clone. + * @return Cloned range coverage. + */ +export function cloneRangeCov(rangeCov) { + return { + startOffset: rangeCov.startOffset, + endOffset: rangeCov.endOffset, + count: rangeCov.count, + }; +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.d.ts new file mode 100644 index 00000000000..5fee68bddbd --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.d.ts @@ -0,0 +1,21 @@ +import { FunctionCov, RangeCov, ScriptCov } from "./types"; +/** + * Compares two script coverages. + * + * The result corresponds to the comparison of their `url` value (alphabetical sort). + */ +export declare function compareScriptCovs(a: Readonly, b: Readonly): number; +/** + * Compares two function coverages. + * + * The result corresponds to the comparison of the root ranges. + */ +export declare function compareFunctionCovs(a: Readonly, b: Readonly): number; +/** + * Compares two range coverages. + * + * The ranges are first ordered by ascending `startOffset` and then by + * descending `endOffset`. + * This corresponds to a pre-order tree traversal. + */ +export declare function compareRangeCovs(a: Readonly, b: Readonly): number; diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.js new file mode 100644 index 00000000000..c723ea0a82a --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.js @@ -0,0 +1,46 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +/** + * Compares two script coverages. + * + * The result corresponds to the comparison of their `url` value (alphabetical sort). + */ +function compareScriptCovs(a, b) { + if (a.url === b.url) { + return 0; + } + else if (a.url < b.url) { + return -1; + } + else { + return 1; + } +} +exports.compareScriptCovs = compareScriptCovs; +/** + * Compares two function coverages. + * + * The result corresponds to the comparison of the root ranges. + */ +function compareFunctionCovs(a, b) { + return compareRangeCovs(a.ranges[0], b.ranges[0]); +} +exports.compareFunctionCovs = compareFunctionCovs; +/** + * Compares two range coverages. + * + * The ranges are first ordered by ascending `startOffset` and then by + * descending `endOffset`. + * This corresponds to a pre-order tree traversal. + */ +function compareRangeCovs(a, b) { + if (a.startOffset !== b.startOffset) { + return a.startOffset - b.startOffset; + } + else { + return b.endOffset - a.endOffset; + } +} +exports.compareRangeCovs = compareRangeCovs; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.mjs new file mode 100644 index 00000000000..c03be82b13b --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/compare.mjs @@ -0,0 +1,41 @@ +/** + * Compares two script coverages. + * + * The result corresponds to the comparison of their `url` value (alphabetical sort). + */ +export function compareScriptCovs(a, b) { + if (a.url === b.url) { + return 0; + } + else if (a.url < b.url) { + return -1; + } + else { + return 1; + } +} +/** + * Compares two function coverages. + * + * The result corresponds to the comparison of the root ranges. + */ +export function compareFunctionCovs(a, b) { + return compareRangeCovs(a.ranges[0], b.ranges[0]); +} +/** + * Compares two range coverages. + * + * The ranges are first ordered by ascending `startOffset` and then by + * descending `endOffset`. + * This corresponds to a pre-order tree traversal. + */ +export function compareRangeCovs(a, b) { + if (a.startOffset !== b.startOffset) { + return a.startOffset - b.startOffset; + } + else { + return b.endOffset - a.endOffset; + } +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.d.ts new file mode 100644 index 00000000000..f92bdf3d4fe --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.d.ts @@ -0,0 +1,6 @@ +export { emitForest, emitForestLines, parseFunctionRanges, parseOffsets } from "./ascii"; +export { cloneFunctionCov, cloneProcessCov, cloneScriptCov, cloneRangeCov } from "./clone"; +export { compareScriptCovs, compareFunctionCovs, compareRangeCovs } from "./compare"; +export { mergeFunctionCovs, mergeProcessCovs, mergeScriptCovs } from "./merge"; +export { RangeTree } from "./range-tree"; +export { ProcessCov, ScriptCov, FunctionCov, RangeCov } from "./types"; diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.js new file mode 100644 index 00000000000..450362d9603 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.js @@ -0,0 +1,24 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var ascii_1 = require("./ascii"); +exports.emitForest = ascii_1.emitForest; +exports.emitForestLines = ascii_1.emitForestLines; +exports.parseFunctionRanges = ascii_1.parseFunctionRanges; +exports.parseOffsets = ascii_1.parseOffsets; +var clone_1 = require("./clone"); +exports.cloneFunctionCov = clone_1.cloneFunctionCov; +exports.cloneProcessCov = clone_1.cloneProcessCov; +exports.cloneScriptCov = clone_1.cloneScriptCov; +exports.cloneRangeCov = clone_1.cloneRangeCov; +var compare_1 = require("./compare"); +exports.compareScriptCovs = compare_1.compareScriptCovs; +exports.compareFunctionCovs = compare_1.compareFunctionCovs; +exports.compareRangeCovs = compare_1.compareRangeCovs; +var merge_1 = require("./merge"); +exports.mergeFunctionCovs = merge_1.mergeFunctionCovs; +exports.mergeProcessCovs = merge_1.mergeProcessCovs; +exports.mergeScriptCovs = merge_1.mergeScriptCovs; +var range_tree_1 = require("./range-tree"); +exports.RangeTree = range_tree_1.RangeTree; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxpQ0FBeUY7QUFBaEYsNkJBQUEsVUFBVSxDQUFBO0FBQUUsa0NBQUEsZUFBZSxDQUFBO0FBQUUsc0NBQUEsbUJBQW1CLENBQUE7QUFBRSwrQkFBQSxZQUFZLENBQUE7QUFDdkUsaUNBQTJGO0FBQWxGLG1DQUFBLGdCQUFnQixDQUFBO0FBQUUsa0NBQUEsZUFBZSxDQUFBO0FBQUUsaUNBQUEsY0FBYyxDQUFBO0FBQUUsZ0NBQUEsYUFBYSxDQUFBO0FBQ3pFLHFDQUFxRjtBQUE1RSxzQ0FBQSxpQkFBaUIsQ0FBQTtBQUFFLHdDQUFBLG1CQUFtQixDQUFBO0FBQUUscUNBQUEsZ0JBQWdCLENBQUE7QUFDakUsaUNBQStFO0FBQXRFLG9DQUFBLGlCQUFpQixDQUFBO0FBQUUsbUNBQUEsZ0JBQWdCLENBQUE7QUFBRSxrQ0FBQSxlQUFlLENBQUE7QUFDN0QsMkNBQXlDO0FBQWhDLGlDQUFBLFNBQVMsQ0FBQSIsImZpbGUiOiJpbmRleC5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGVtaXRGb3Jlc3QsIGVtaXRGb3Jlc3RMaW5lcywgcGFyc2VGdW5jdGlvblJhbmdlcywgcGFyc2VPZmZzZXRzIH0gZnJvbSBcIi4vYXNjaWlcIjtcbmV4cG9ydCB7IGNsb25lRnVuY3Rpb25Db3YsIGNsb25lUHJvY2Vzc0NvdiwgY2xvbmVTY3JpcHRDb3YsIGNsb25lUmFuZ2VDb3YgfSBmcm9tIFwiLi9jbG9uZVwiO1xuZXhwb3J0IHsgY29tcGFyZVNjcmlwdENvdnMsIGNvbXBhcmVGdW5jdGlvbkNvdnMsIGNvbXBhcmVSYW5nZUNvdnMgfSBmcm9tIFwiLi9jb21wYXJlXCI7XG5leHBvcnQgeyBtZXJnZUZ1bmN0aW9uQ292cywgbWVyZ2VQcm9jZXNzQ292cywgbWVyZ2VTY3JpcHRDb3ZzIH0gZnJvbSBcIi4vbWVyZ2VcIjtcbmV4cG9ydCB7IFJhbmdlVHJlZSB9IGZyb20gXCIuL3JhbmdlLXRyZWVcIjtcbmV4cG9ydCB7IFByb2Nlc3NDb3YsIFNjcmlwdENvdiwgRnVuY3Rpb25Db3YsIFJhbmdlQ292IH0gZnJvbSBcIi4vdHlwZXNcIjtcbiJdLCJzb3VyY2VSb290IjoiIn0= diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.mjs new file mode 100644 index 00000000000..30d8ce1f27a --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/index.mjs @@ -0,0 +1,7 @@ +export { emitForest, emitForestLines, parseFunctionRanges, parseOffsets } from "./ascii"; +export { cloneFunctionCov, cloneProcessCov, cloneScriptCov, cloneRangeCov } from "./clone"; +export { compareScriptCovs, compareFunctionCovs, compareRangeCovs } from "./compare"; +export { mergeFunctionCovs, mergeProcessCovs, mergeScriptCovs } from "./merge"; +export { RangeTree } from "./range-tree"; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsbUJBQW1CLEVBQUUsWUFBWSxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3pGLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLGFBQWEsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUMzRixPQUFPLEVBQUUsaUJBQWlCLEVBQUUsbUJBQW1CLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFDckYsT0FBTyxFQUFFLGlCQUFpQixFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUMvRSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sY0FBYyxDQUFDIiwiZmlsZSI6ImluZGV4LmpzIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZW1pdEZvcmVzdCwgZW1pdEZvcmVzdExpbmVzLCBwYXJzZUZ1bmN0aW9uUmFuZ2VzLCBwYXJzZU9mZnNldHMgfSBmcm9tIFwiLi9hc2NpaVwiO1xuZXhwb3J0IHsgY2xvbmVGdW5jdGlvbkNvdiwgY2xvbmVQcm9jZXNzQ292LCBjbG9uZVNjcmlwdENvdiwgY2xvbmVSYW5nZUNvdiB9IGZyb20gXCIuL2Nsb25lXCI7XG5leHBvcnQgeyBjb21wYXJlU2NyaXB0Q292cywgY29tcGFyZUZ1bmN0aW9uQ292cywgY29tcGFyZVJhbmdlQ292cyB9IGZyb20gXCIuL2NvbXBhcmVcIjtcbmV4cG9ydCB7IG1lcmdlRnVuY3Rpb25Db3ZzLCBtZXJnZVByb2Nlc3NDb3ZzLCBtZXJnZVNjcmlwdENvdnMgfSBmcm9tIFwiLi9tZXJnZVwiO1xuZXhwb3J0IHsgUmFuZ2VUcmVlIH0gZnJvbSBcIi4vcmFuZ2UtdHJlZVwiO1xuZXhwb3J0IHsgUHJvY2Vzc0NvdiwgU2NyaXB0Q292LCBGdW5jdGlvbkNvdiwgUmFuZ2VDb3YgfSBmcm9tIFwiLi90eXBlc1wiO1xuIl0sInNvdXJjZVJvb3QiOiIifQ== diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.d.ts new file mode 100644 index 00000000000..5095383f08f --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.d.ts @@ -0,0 +1,39 @@ +import { FunctionCov, ProcessCov, ScriptCov } from "./types"; +/** + * Merges a list of process coverages. + * + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param processCovs Process coverages to merge. + * @return Merged process coverage. + */ +export declare function mergeProcessCovs(processCovs: ReadonlyArray): ProcessCov; +/** + * Merges a list of matching script coverages. + * + * Scripts are matching if they have the same `url`. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param scriptCovs Process coverages to merge. + * @return Merged script coverage, or `undefined` if the input list was empty. + */ +export declare function mergeScriptCovs(scriptCovs: ReadonlyArray): ScriptCov | undefined; +/** + * Merges a list of matching function coverages. + * + * Functions are matching if their root ranges have the same span. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param funcCovs Function coverages to merge. + * @return Merged function coverage, or `undefined` if the input list was empty. + */ +export declare function mergeFunctionCovs(funcCovs: ReadonlyArray): FunctionCov | undefined; diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.js new file mode 100644 index 00000000000..c2b5a8cd6f6 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.js @@ -0,0 +1,302 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const normalize_1 = require("./normalize"); +const range_tree_1 = require("./range-tree"); +/** + * Merges a list of process coverages. + * + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param processCovs Process coverages to merge. + * @return Merged process coverage. + */ +function mergeProcessCovs(processCovs) { + if (processCovs.length === 0) { + return { result: [] }; + } + const urlToScripts = new Map(); + for (const processCov of processCovs) { + for (const scriptCov of processCov.result) { + let scriptCovs = urlToScripts.get(scriptCov.url); + if (scriptCovs === undefined) { + scriptCovs = []; + urlToScripts.set(scriptCov.url, scriptCovs); + } + scriptCovs.push(scriptCov); + } + } + const result = []; + for (const scripts of urlToScripts.values()) { + // assert: `scripts.length > 0` + result.push(mergeScriptCovs(scripts)); + } + const merged = { result }; + normalize_1.normalizeProcessCov(merged); + return merged; +} +exports.mergeProcessCovs = mergeProcessCovs; +/** + * Merges a list of matching script coverages. + * + * Scripts are matching if they have the same `url`. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param scriptCovs Process coverages to merge. + * @return Merged script coverage, or `undefined` if the input list was empty. + */ +function mergeScriptCovs(scriptCovs) { + if (scriptCovs.length === 0) { + return undefined; + } + else if (scriptCovs.length === 1) { + const merged = scriptCovs[0]; + normalize_1.deepNormalizeScriptCov(merged); + return merged; + } + const first = scriptCovs[0]; + const scriptId = first.scriptId; + const url = first.url; + const rangeToFuncs = new Map(); + for (const scriptCov of scriptCovs) { + for (const funcCov of scriptCov.functions) { + const rootRange = stringifyFunctionRootRange(funcCov); + let funcCovs = rangeToFuncs.get(rootRange); + if (funcCovs === undefined || + // if the entry in rangeToFuncs is function-level granularity and + // the new coverage is block-level, prefer block-level. + (!funcCovs[0].isBlockCoverage && funcCov.isBlockCoverage)) { + funcCovs = []; + rangeToFuncs.set(rootRange, funcCovs); + } + else if (funcCovs[0].isBlockCoverage && !funcCov.isBlockCoverage) { + // if the entry in rangeToFuncs is block-level granularity, we should + // not append function level granularity. + continue; + } + funcCovs.push(funcCov); + } + } + const functions = []; + for (const funcCovs of rangeToFuncs.values()) { + // assert: `funcCovs.length > 0` + functions.push(mergeFunctionCovs(funcCovs)); + } + const merged = { scriptId, url, functions }; + normalize_1.normalizeScriptCov(merged); + return merged; +} +exports.mergeScriptCovs = mergeScriptCovs; +/** + * Returns a string representation of the root range of the function. + * + * This string can be used to match function with same root range. + * The string is derived from the start and end offsets of the root range of + * the function. + * This assumes that `ranges` is non-empty (true for valid function coverages). + * + * @param funcCov Function coverage with the range to stringify + * @internal + */ +function stringifyFunctionRootRange(funcCov) { + const rootRange = funcCov.ranges[0]; + return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`; +} +/** + * Merges a list of matching function coverages. + * + * Functions are matching if their root ranges have the same span. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param funcCovs Function coverages to merge. + * @return Merged function coverage, or `undefined` if the input list was empty. + */ +function mergeFunctionCovs(funcCovs) { + if (funcCovs.length === 0) { + return undefined; + } + else if (funcCovs.length === 1) { + const merged = funcCovs[0]; + normalize_1.normalizeFunctionCov(merged); + return merged; + } + const functionName = funcCovs[0].functionName; + const trees = []; + for (const funcCov of funcCovs) { + // assert: `fn.ranges.length > 0` + // assert: `fn.ranges` is sorted + trees.push(range_tree_1.RangeTree.fromSortedRanges(funcCov.ranges)); + } + // assert: `trees.length > 0` + const mergedTree = mergeRangeTrees(trees); + normalize_1.normalizeRangeTree(mergedTree); + const ranges = mergedTree.toRanges(); + const isBlockCoverage = !(ranges.length === 1 && ranges[0].count === 0); + const merged = { functionName, ranges, isBlockCoverage }; + // assert: `merged` is normalized + return merged; +} +exports.mergeFunctionCovs = mergeFunctionCovs; +/** + * @precondition Same `start` and `end` for all the trees + */ +function mergeRangeTrees(trees) { + if (trees.length <= 1) { + return trees[0]; + } + const first = trees[0]; + let delta = 0; + for (const tree of trees) { + delta += tree.delta; + } + const children = mergeRangeTreeChildren(trees); + return new range_tree_1.RangeTree(first.start, first.end, delta, children); +} +class RangeTreeWithParent { + constructor(parentIndex, tree) { + this.parentIndex = parentIndex; + this.tree = tree; + } +} +class StartEvent { + constructor(offset, trees) { + this.offset = offset; + this.trees = trees; + } + static compare(a, b) { + return a.offset - b.offset; + } +} +class StartEventQueue { + constructor(queue) { + this.queue = queue; + this.nextIndex = 0; + this.pendingOffset = 0; + this.pendingTrees = undefined; + } + static fromParentTrees(parentTrees) { + const startToTrees = new Map(); + for (const [parentIndex, parentTree] of parentTrees.entries()) { + for (const child of parentTree.children) { + let trees = startToTrees.get(child.start); + if (trees === undefined) { + trees = []; + startToTrees.set(child.start, trees); + } + trees.push(new RangeTreeWithParent(parentIndex, child)); + } + } + const queue = []; + for (const [startOffset, trees] of startToTrees) { + queue.push(new StartEvent(startOffset, trees)); + } + queue.sort(StartEvent.compare); + return new StartEventQueue(queue); + } + setPendingOffset(offset) { + this.pendingOffset = offset; + } + pushPendingTree(tree) { + if (this.pendingTrees === undefined) { + this.pendingTrees = []; + } + this.pendingTrees.push(tree); + } + next() { + const pendingTrees = this.pendingTrees; + const nextEvent = this.queue[this.nextIndex]; + if (pendingTrees === undefined) { + this.nextIndex++; + return nextEvent; + } + else if (nextEvent === undefined) { + this.pendingTrees = undefined; + return new StartEvent(this.pendingOffset, pendingTrees); + } + else { + if (this.pendingOffset < nextEvent.offset) { + this.pendingTrees = undefined; + return new StartEvent(this.pendingOffset, pendingTrees); + } + else { + if (this.pendingOffset === nextEvent.offset) { + this.pendingTrees = undefined; + for (const tree of pendingTrees) { + nextEvent.trees.push(tree); + } + } + this.nextIndex++; + return nextEvent; + } + } + } +} +function mergeRangeTreeChildren(parentTrees) { + const result = []; + const startEventQueue = StartEventQueue.fromParentTrees(parentTrees); + const parentToNested = new Map(); + let openRange; + while (true) { + const event = startEventQueue.next(); + if (event === undefined) { + break; + } + if (openRange !== undefined && openRange.end <= event.offset) { + result.push(nextChild(openRange, parentToNested)); + openRange = undefined; + } + if (openRange === undefined) { + let openRangeEnd = event.offset + 1; + for (const { parentIndex, tree } of event.trees) { + openRangeEnd = Math.max(openRangeEnd, tree.end); + insertChild(parentToNested, parentIndex, tree); + } + startEventQueue.setPendingOffset(openRangeEnd); + openRange = { start: event.offset, end: openRangeEnd }; + } + else { + for (const { parentIndex, tree } of event.trees) { + if (tree.end > openRange.end) { + const right = tree.split(openRange.end); + startEventQueue.pushPendingTree(new RangeTreeWithParent(parentIndex, right)); + } + insertChild(parentToNested, parentIndex, tree); + } + } + } + if (openRange !== undefined) { + result.push(nextChild(openRange, parentToNested)); + } + return result; +} +function insertChild(parentToNested, parentIndex, tree) { + let nested = parentToNested.get(parentIndex); + if (nested === undefined) { + nested = []; + parentToNested.set(parentIndex, nested); + } + nested.push(tree); +} +function nextChild(openRange, parentToNested) { + const matchingTrees = []; + for (const nested of parentToNested.values()) { + if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) { + matchingTrees.push(nested[0]); + } + else { + matchingTrees.push(new range_tree_1.RangeTree(openRange.start, openRange.end, 0, nested)); + } + } + parentToNested.clear(); + return mergeRangeTrees(matchingTrees); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/merge.ts"],"names":[],"mappings":";;AAAA,2CAMqB;AACrB,6CAAyC;AAGzC;;;;;;;;;;GAUG;AACH,SAAgB,gBAAgB,CAAC,WAAsC;IACrE,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;QAC5B,OAAO,EAAC,MAAM,EAAE,EAAE,EAAC,CAAC;KACrB;IAED,MAAM,YAAY,GAA6B,IAAI,GAAG,EAAE,CAAC;IACzD,KAAK,MAAM,UAAU,IAAI,WAAW,EAAE;QACpC,KAAK,MAAM,SAAS,IAAI,UAAU,CAAC,MAAM,EAAE;YACzC,IAAI,UAAU,GAA4B,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;YAC1E,IAAI,UAAU,KAAK,SAAS,EAAE;gBAC5B,UAAU,GAAG,EAAE,CAAC;gBAChB,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,UAAU,CAAC,CAAC;aAC7C;YACD,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAC5B;KACF;IAED,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,KAAK,MAAM,OAAO,IAAI,YAAY,CAAC,MAAM,EAAE,EAAE;QAC3C,+BAA+B;QAC/B,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,OAAO,CAAE,CAAC,CAAC;KACxC;IACD,MAAM,MAAM,GAAe,EAAC,MAAM,EAAC,CAAC;IAEpC,+BAAmB,CAAC,MAAM,CAAC,CAAC;IAC5B,OAAO,MAAM,CAAC;AAChB,CAAC;AA1BD,4CA0BC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,eAAe,CAAC,UAAoC;IAClE,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;QAC3B,OAAO,SAAS,CAAC;KAClB;SAAM,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;QAClC,MAAM,MAAM,GAAc,UAAU,CAAC,CAAC,CAAC,CAAC;QACxC,kCAAsB,CAAC,MAAM,CAAC,CAAC;QAC/B,OAAO,MAAM,CAAC;KACf;IAED,MAAM,KAAK,GAAc,UAAU,CAAC,CAAC,CAAC,CAAC;IACvC,MAAM,QAAQ,GAAW,KAAK,CAAC,QAAQ,CAAC;IACxC,MAAM,GAAG,GAAW,KAAK,CAAC,GAAG,CAAC;IAE9B,MAAM,YAAY,GAA+B,IAAI,GAAG,EAAE,CAAC;IAC3D,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE;QAClC,KAAK,MAAM,OAAO,IAAI,SAAS,CAAC,SAAS,EAAE;YACzC,MAAM,SAAS,GAAW,0BAA0B,CAAC,OAAO,CAAC,CAAC;YAC9D,IAAI,QAAQ,GAA8B,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YAEtE,IAAI,QAAQ,KAAK,SAAS;gBACxB,iEAAiE;gBACjE,uDAAuD;gBACvD,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,eAAe,IAAI,OAAO,CAAC,eAAe,CAAC,EAAE;gBAC3D,QAAQ,GAAG,EAAE,CAAC;gBACd,YAAY,CAAC,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;aACvC;iBAAM,IAAI,QAAQ,CAAC,CAAC,CAAC,CAAC,eAAe,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE;gBAClE,qEAAqE;gBACrE,yCAAyC;gBACzC,SAAS;aACV;YACD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SACxB;KACF;IAED,MAAM,SAAS,GAAkB,EAAE,CAAC;IACpC,KAAK,MAAM,QAAQ,IAAI,YAAY,CAAC,MAAM,EAAE,EAAE;QAC5C,gCAAgC;QAChC,SAAS,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAE,CAAC,CAAC;KAC9C;IAED,MAAM,MAAM,GAAc,EAAC,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAC,CAAC;IACrD,8BAAkB,CAAC,MAAM,CAAC,CAAC;IAC3B,OAAO,MAAM,CAAC;AAChB,CAAC;AA3CD,0CA2CC;AAED;;;;;;;;;;GAUG;AACH,SAAS,0BAA0B,CAAC,OAA8B;IAChE,MAAM,SAAS,GAAa,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAC9C,OAAO,GAAG,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,CAAC;AACrF,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,iBAAiB,CAAC,QAAoC;IACpE,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QACzB,OAAO,SAAS,CAAC;KAClB;SAAM,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QAChC,MAAM,MAAM,GAAgB,QAAQ,CAAC,CAAC,CAAC,CAAC;QACxC,gCAAoB,CAAC,MAAM,CAAC,CAAC;QAC7B,OAAO,MAAM,CAAC;KACf;IAED,MAAM,YAAY,GAAW,QAAQ,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC;IAEtD,MAAM,KAAK,GAAgB,EAAE,CAAC;IAC9B,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE;QAC9B,iCAAiC;QACjC,gCAAgC;QAChC,KAAK,CAAC,IAAI,CAAC,sBAAS,CAAC,gBAAgB,CAAC,OAAO,CAAC,MAAM,CAAE,CAAC,CAAC;KACzD;IAED,6BAA6B;IAC7B,MAAM,UAAU,GAAc,eAAe,CAAC,KAAK,CAAE,CAAC;IACtD,8BAAkB,CAAC,UAAU,CAAC,CAAC;IAC/B,MAAM,MAAM,GAAe,UAAU,CAAC,QAAQ,EAAE,CAAC;IACjD,MAAM,eAAe,GAAY,CAAC,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC;IAEjF,MAAM,MAAM,GAAgB,EAAC,YAAY,EAAE,MAAM,EAAE,eAAe,EAAC,CAAC;IACpE,iCAAiC;IACjC,OAAO,MAAM,CAAC;AAChB,CAAC;AA3BD,8CA2BC;AAED;;GAEG;AACH,SAAS,eAAe,CAAC,KAA+B;IACtD,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,EAAE;QACrB,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;KACjB;IACD,MAAM,KAAK,GAAc,KAAK,CAAC,CAAC,CAAC,CAAC;IAClC,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE;QACxB,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC;KACrB;IACD,MAAM,QAAQ,GAAgB,sBAAsB,CAAC,KAAK,CAAC,CAAC;IAC5D,OAAO,IAAI,sBAAS,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;AAChE,CAAC;AAED,MAAM,mBAAmB;IAIvB,YAAY,WAAmB,EAAE,IAAe;QAC9C,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;CACF;AAED,MAAM,UAAU;IAId,YAAY,MAAc,EAAE,KAA4B;QACtD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED,MAAM,CAAC,OAAO,CAAC,CAAa,EAAE,CAAa;QACzC,OAAO,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7B,CAAC;CACF;AAED,MAAM,eAAe;IAMnB,YAAoB,KAAmB;QACrC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACvB,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;IAChC,CAAC;IAED,MAAM,CAAC,eAAe,CAAC,WAAqC;QAC1D,MAAM,YAAY,GAAuC,IAAI,GAAG,EAAE,CAAC;QACnE,KAAK,MAAM,CAAC,WAAW,EAAE,UAAU,CAAC,IAAI,WAAW,CAAC,OAAO,EAAE,EAAE;YAC7D,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,QAAQ,EAAE;gBACvC,IAAI,KAAK,GAAsC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC7E,IAAI,KAAK,KAAK,SAAS,EAAE;oBACvB,KAAK,GAAG,EAAE,CAAC;oBACX,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;iBACtC;gBACD,KAAK,CAAC,IAAI,CAAC,IAAI,mBAAmB,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC;aACzD;SACF;QACD,MAAM,KAAK,GAAiB,EAAE,CAAC;QAC/B,KAAK,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,IAAI,YAAY,EAAE;YAC/C,KAAK,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC;SAChD;QACD,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAC/B,OAAO,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAED,gBAAgB,CAAC,MAAc;QAC7B,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC;IAC9B,CAAC;IAED,eAAe,CAAC,IAAyB;QACvC,IAAI,IAAI,CAAC,YAAY,KAAK,SAAS,EAAE;YACnC,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;SACxB;QACD,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,IAAI;QACF,MAAM,YAAY,GAAsC,IAAI,CAAC,YAAY,CAAC;QAC1E,MAAM,SAAS,GAA2B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QACrE,IAAI,YAAY,KAAK,SAAS,EAAE;YAC9B,IAAI,CAAC,SAAS,EAAE,CAAC;YACjB,OAAO,SAAS,CAAC;SAClB;aAAM,IAAI,SAAS,KAAK,SAAS,EAAE;YAClC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;YAC9B,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;SACzD;aAAM;YACL,IAAI,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC,MAAM,EAAE;gBACzC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;gBAC9B,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;aACzD;iBAAM;gBACL,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,CAAC,MAAM,EAAE;oBAC3C,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;oBAC9B,KAAK,MAAM,IAAI,IAAI,YAAY,EAAE;wBAC/B,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;qBAC5B;iBACF;gBACD,IAAI,CAAC,SAAS,EAAE,CAAC;gBACjB,OAAO,SAAS,CAAC;aAClB;SACF;IACH,CAAC;CACF;AAED,SAAS,sBAAsB,CAAC,WAAqC;IACnE,MAAM,MAAM,GAAgB,EAAE,CAAC;IAC/B,MAAM,eAAe,GAAoB,eAAe,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC;IACtF,MAAM,cAAc,GAA6B,IAAI,GAAG,EAAE,CAAC;IAC3D,IAAI,SAA4B,CAAC;IAEjC,OAAO,IAAI,EAAE;QACX,MAAM,KAAK,GAA2B,eAAe,CAAC,IAAI,EAAE,CAAC;QAC7D,IAAI,KAAK,KAAK,SAAS,EAAE;YACvB,MAAM;SACP;QAED,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,CAAC,GAAG,IAAI,KAAK,CAAC,MAAM,EAAE;YAC5D,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;YAClD,SAAS,GAAG,SAAS,CAAC;SACvB;QAED,IAAI,SAAS,KAAK,SAAS,EAAE;YAC3B,IAAI,YAAY,GAAW,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;YAC5C,KAAK,MAAM,EAAC,WAAW,EAAE,IAAI,EAAC,IAAI,KAAK,CAAC,KAAK,EAAE;gBAC7C,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;gBAChD,WAAW,CAAC,cAAc,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;aAChD;YACD,eAAe,CAAC,gBAAgB,CAAC,YAAY,CAAC,CAAC;YAC/C,SAAS,GAAG,EAAC,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE,YAAY,EAAC,CAAC;SACtD;aAAM;YACL,KAAK,MAAM,EAAC,WAAW,EAAE,IAAI,EAAC,IAAI,KAAK,CAAC,KAAK,EAAE;gBAC7C,IAAI,IAAI,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,EAAE;oBAC5B,MAAM,KAAK,GAAc,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;oBACnD,eAAe,CAAC,eAAe,CAAC,IAAI,mBAAmB,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC;iBAC9E;gBACD,WAAW,CAAC,cAAc,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC;aAChD;SACF;KACF;IACD,IAAI,SAAS,KAAK,SAAS,EAAE;QAC3B,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;KACnD;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,WAAW,CAAC,cAAwC,EAAE,WAAmB,EAAE,IAAe;IACjG,IAAI,MAAM,GAA4B,cAAc,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;IACtE,IAAI,MAAM,KAAK,SAAS,EAAE;QACxB,MAAM,GAAG,EAAE,CAAC;QACZ,cAAc,CAAC,GAAG,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC;KACzC;IACD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACpB,CAAC;AAED,SAAS,SAAS,CAAC,SAAgB,EAAE,cAAwC;IAC3E,MAAM,aAAa,GAAgB,EAAE,CAAC;IAEtC,KAAK,MAAM,MAAM,IAAI,cAAc,CAAC,MAAM,EAAE,EAAE;QAC5C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,KAAK,IAAI,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,SAAS,CAAC,GAAG,EAAE;YACjG,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/B;aAAM;YACL,aAAa,CAAC,IAAI,CAAC,IAAI,sBAAS,CAC9B,SAAS,CAAC,KAAK,EACf,SAAS,CAAC,GAAG,EACb,CAAC,EACD,MAAM,CACP,CAAC,CAAC;SACJ;KACF;IACD,cAAc,CAAC,KAAK,EAAE,CAAC;IACvB,OAAO,eAAe,CAAC,aAAa,CAAE,CAAC;AACzC,CAAC","file":"merge.js","sourcesContent":["import {\n  deepNormalizeScriptCov,\n  normalizeFunctionCov,\n  normalizeProcessCov,\n  normalizeRangeTree,\n  normalizeScriptCov,\n} from \"./normalize\";\nimport { RangeTree } from \"./range-tree\";\nimport { FunctionCov, ProcessCov, Range, RangeCov, ScriptCov } from \"./types\";\n\n/**\n * Merges a list of process coverages.\n *\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param processCovs Process coverages to merge.\n * @return Merged process coverage.\n */\nexport function mergeProcessCovs(processCovs: ReadonlyArray<ProcessCov>): ProcessCov {\n  if (processCovs.length === 0) {\n    return {result: []};\n  }\n\n  const urlToScripts: Map<string, ScriptCov[]> = new Map();\n  for (const processCov of processCovs) {\n    for (const scriptCov of processCov.result) {\n      let scriptCovs: ScriptCov[] | undefined = urlToScripts.get(scriptCov.url);\n      if (scriptCovs === undefined) {\n        scriptCovs = [];\n        urlToScripts.set(scriptCov.url, scriptCovs);\n      }\n      scriptCovs.push(scriptCov);\n    }\n  }\n\n  const result: ScriptCov[] = [];\n  for (const scripts of urlToScripts.values()) {\n    // assert: `scripts.length > 0`\n    result.push(mergeScriptCovs(scripts)!);\n  }\n  const merged: ProcessCov = {result};\n\n  normalizeProcessCov(merged);\n  return merged;\n}\n\n/**\n * Merges a list of matching script coverages.\n *\n * Scripts are matching if they have the same `url`.\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param scriptCovs Process coverages to merge.\n * @return Merged script coverage, or `undefined` if the input list was empty.\n */\nexport function mergeScriptCovs(scriptCovs: ReadonlyArray<ScriptCov>): ScriptCov | undefined {\n  if (scriptCovs.length === 0) {\n    return undefined;\n  } else if (scriptCovs.length === 1) {\n    const merged: ScriptCov = scriptCovs[0];\n    deepNormalizeScriptCov(merged);\n    return merged;\n  }\n\n  const first: ScriptCov = scriptCovs[0];\n  const scriptId: string = first.scriptId;\n  const url: string = first.url;\n\n  const rangeToFuncs: Map<string, FunctionCov[]> = new Map();\n  for (const scriptCov of scriptCovs) {\n    for (const funcCov of scriptCov.functions) {\n      const rootRange: string = stringifyFunctionRootRange(funcCov);\n      let funcCovs: FunctionCov[] | undefined = rangeToFuncs.get(rootRange);\n\n      if (funcCovs === undefined ||\n        // if the entry in rangeToFuncs is function-level granularity and\n        // the new coverage is block-level, prefer block-level.\n        (!funcCovs[0].isBlockCoverage && funcCov.isBlockCoverage)) {\n        funcCovs = [];\n        rangeToFuncs.set(rootRange, funcCovs);\n      } else if (funcCovs[0].isBlockCoverage && !funcCov.isBlockCoverage) {\n        // if the entry in rangeToFuncs is block-level granularity, we should\n        // not append function level granularity.\n        continue;\n      }\n      funcCovs.push(funcCov);\n    }\n  }\n\n  const functions: FunctionCov[] = [];\n  for (const funcCovs of rangeToFuncs.values()) {\n    // assert: `funcCovs.length > 0`\n    functions.push(mergeFunctionCovs(funcCovs)!);\n  }\n\n  const merged: ScriptCov = {scriptId, url, functions};\n  normalizeScriptCov(merged);\n  return merged;\n}\n\n/**\n * Returns a string representation of the root range of the function.\n *\n * This string can be used to match function with same root range.\n * The string is derived from the start and end offsets of the root range of\n * the function.\n * This assumes that `ranges` is non-empty (true for valid function coverages).\n *\n * @param funcCov Function coverage with the range to stringify\n * @internal\n */\nfunction stringifyFunctionRootRange(funcCov: Readonly<FunctionCov>): string {\n  const rootRange: RangeCov = funcCov.ranges[0];\n  return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`;\n}\n\n/**\n * Merges a list of matching function coverages.\n *\n * Functions are matching if their root ranges have the same span.\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param funcCovs Function coverages to merge.\n * @return Merged function coverage, or `undefined` if the input list was empty.\n */\nexport function mergeFunctionCovs(funcCovs: ReadonlyArray<FunctionCov>): FunctionCov | undefined {\n  if (funcCovs.length === 0) {\n    return undefined;\n  } else if (funcCovs.length === 1) {\n    const merged: FunctionCov = funcCovs[0];\n    normalizeFunctionCov(merged);\n    return merged;\n  }\n\n  const functionName: string = funcCovs[0].functionName;\n\n  const trees: RangeTree[] = [];\n  for (const funcCov of funcCovs) {\n    // assert: `fn.ranges.length > 0`\n    // assert: `fn.ranges` is sorted\n    trees.push(RangeTree.fromSortedRanges(funcCov.ranges)!);\n  }\n\n  // assert: `trees.length > 0`\n  const mergedTree: RangeTree = mergeRangeTrees(trees)!;\n  normalizeRangeTree(mergedTree);\n  const ranges: RangeCov[] = mergedTree.toRanges();\n  const isBlockCoverage: boolean = !(ranges.length === 1 && ranges[0].count === 0);\n\n  const merged: FunctionCov = {functionName, ranges, isBlockCoverage};\n  // assert: `merged` is normalized\n  return merged;\n}\n\n/**\n * @precondition Same `start` and `end` for all the trees\n */\nfunction mergeRangeTrees(trees: ReadonlyArray<RangeTree>): RangeTree | undefined {\n  if (trees.length <= 1) {\n    return trees[0];\n  }\n  const first: RangeTree = trees[0];\n  let delta: number = 0;\n  for (const tree of trees) {\n    delta += tree.delta;\n  }\n  const children: RangeTree[] = mergeRangeTreeChildren(trees);\n  return new RangeTree(first.start, first.end, delta, children);\n}\n\nclass RangeTreeWithParent {\n  readonly parentIndex: number;\n  readonly tree: RangeTree;\n\n  constructor(parentIndex: number, tree: RangeTree) {\n    this.parentIndex = parentIndex;\n    this.tree = tree;\n  }\n}\n\nclass StartEvent {\n  readonly offset: number;\n  readonly trees: RangeTreeWithParent[];\n\n  constructor(offset: number, trees: RangeTreeWithParent[]) {\n    this.offset = offset;\n    this.trees = trees;\n  }\n\n  static compare(a: StartEvent, b: StartEvent): number {\n    return a.offset - b.offset;\n  }\n}\n\nclass StartEventQueue {\n  private readonly queue: StartEvent[];\n  private nextIndex: number;\n  private pendingOffset: number;\n  private pendingTrees: RangeTreeWithParent[] | undefined;\n\n  private constructor(queue: StartEvent[]) {\n    this.queue = queue;\n    this.nextIndex = 0;\n    this.pendingOffset = 0;\n    this.pendingTrees = undefined;\n  }\n\n  static fromParentTrees(parentTrees: ReadonlyArray<RangeTree>): StartEventQueue {\n    const startToTrees: Map<number, RangeTreeWithParent[]> = new Map();\n    for (const [parentIndex, parentTree] of parentTrees.entries()) {\n      for (const child of parentTree.children) {\n        let trees: RangeTreeWithParent[] | undefined = startToTrees.get(child.start);\n        if (trees === undefined) {\n          trees = [];\n          startToTrees.set(child.start, trees);\n        }\n        trees.push(new RangeTreeWithParent(parentIndex, child));\n      }\n    }\n    const queue: StartEvent[] = [];\n    for (const [startOffset, trees] of startToTrees) {\n      queue.push(new StartEvent(startOffset, trees));\n    }\n    queue.sort(StartEvent.compare);\n    return new StartEventQueue(queue);\n  }\n\n  setPendingOffset(offset: number): void {\n    this.pendingOffset = offset;\n  }\n\n  pushPendingTree(tree: RangeTreeWithParent): void {\n    if (this.pendingTrees === undefined) {\n      this.pendingTrees = [];\n    }\n    this.pendingTrees.push(tree);\n  }\n\n  next(): StartEvent | undefined {\n    const pendingTrees: RangeTreeWithParent[] | undefined = this.pendingTrees;\n    const nextEvent: StartEvent | undefined = this.queue[this.nextIndex];\n    if (pendingTrees === undefined) {\n      this.nextIndex++;\n      return nextEvent;\n    } else if (nextEvent === undefined) {\n      this.pendingTrees = undefined;\n      return new StartEvent(this.pendingOffset, pendingTrees);\n    } else {\n      if (this.pendingOffset < nextEvent.offset) {\n        this.pendingTrees = undefined;\n        return new StartEvent(this.pendingOffset, pendingTrees);\n      } else {\n        if (this.pendingOffset === nextEvent.offset) {\n          this.pendingTrees = undefined;\n          for (const tree of pendingTrees) {\n            nextEvent.trees.push(tree);\n          }\n        }\n        this.nextIndex++;\n        return nextEvent;\n      }\n    }\n  }\n}\n\nfunction mergeRangeTreeChildren(parentTrees: ReadonlyArray<RangeTree>): RangeTree[] {\n  const result: RangeTree[] = [];\n  const startEventQueue: StartEventQueue = StartEventQueue.fromParentTrees(parentTrees);\n  const parentToNested: Map<number, RangeTree[]> = new Map();\n  let openRange: Range | undefined;\n\n  while (true) {\n    const event: StartEvent | undefined = startEventQueue.next();\n    if (event === undefined) {\n      break;\n    }\n\n    if (openRange !== undefined && openRange.end <= event.offset) {\n      result.push(nextChild(openRange, parentToNested));\n      openRange = undefined;\n    }\n\n    if (openRange === undefined) {\n      let openRangeEnd: number = event.offset + 1;\n      for (const {parentIndex, tree} of event.trees) {\n        openRangeEnd = Math.max(openRangeEnd, tree.end);\n        insertChild(parentToNested, parentIndex, tree);\n      }\n      startEventQueue.setPendingOffset(openRangeEnd);\n      openRange = {start: event.offset, end: openRangeEnd};\n    } else {\n      for (const {parentIndex, tree} of event.trees) {\n        if (tree.end > openRange.end) {\n          const right: RangeTree = tree.split(openRange.end);\n          startEventQueue.pushPendingTree(new RangeTreeWithParent(parentIndex, right));\n        }\n        insertChild(parentToNested, parentIndex, tree);\n      }\n    }\n  }\n  if (openRange !== undefined) {\n    result.push(nextChild(openRange, parentToNested));\n  }\n\n  return result;\n}\n\nfunction insertChild(parentToNested: Map<number, RangeTree[]>, parentIndex: number, tree: RangeTree): void {\n  let nested: RangeTree[] | undefined = parentToNested.get(parentIndex);\n  if (nested === undefined) {\n    nested = [];\n    parentToNested.set(parentIndex, nested);\n  }\n  nested.push(tree);\n}\n\nfunction nextChild(openRange: Range, parentToNested: Map<number, RangeTree[]>): RangeTree {\n  const matchingTrees: RangeTree[] = [];\n\n  for (const nested of parentToNested.values()) {\n    if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) {\n      matchingTrees.push(nested[0]);\n    } else {\n      matchingTrees.push(new RangeTree(\n        openRange.start,\n        openRange.end,\n        0,\n        nested,\n      ));\n    }\n  }\n  parentToNested.clear();\n  return mergeRangeTrees(matchingTrees)!;\n}\n"],"sourceRoot":""} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.mjs new file mode 100644 index 00000000000..242fce91bda --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/merge.mjs @@ -0,0 +1,297 @@ +import { deepNormalizeScriptCov, normalizeFunctionCov, normalizeProcessCov, normalizeRangeTree, normalizeScriptCov, } from "./normalize"; +import { RangeTree } from "./range-tree"; +/** + * Merges a list of process coverages. + * + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param processCovs Process coverages to merge. + * @return Merged process coverage. + */ +export function mergeProcessCovs(processCovs) { + if (processCovs.length === 0) { + return { result: [] }; + } + const urlToScripts = new Map(); + for (const processCov of processCovs) { + for (const scriptCov of processCov.result) { + let scriptCovs = urlToScripts.get(scriptCov.url); + if (scriptCovs === undefined) { + scriptCovs = []; + urlToScripts.set(scriptCov.url, scriptCovs); + } + scriptCovs.push(scriptCov); + } + } + const result = []; + for (const scripts of urlToScripts.values()) { + // assert: `scripts.length > 0` + result.push(mergeScriptCovs(scripts)); + } + const merged = { result }; + normalizeProcessCov(merged); + return merged; +} +/** + * Merges a list of matching script coverages. + * + * Scripts are matching if they have the same `url`. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param scriptCovs Process coverages to merge. + * @return Merged script coverage, or `undefined` if the input list was empty. + */ +export function mergeScriptCovs(scriptCovs) { + if (scriptCovs.length === 0) { + return undefined; + } + else if (scriptCovs.length === 1) { + const merged = scriptCovs[0]; + deepNormalizeScriptCov(merged); + return merged; + } + const first = scriptCovs[0]; + const scriptId = first.scriptId; + const url = first.url; + const rangeToFuncs = new Map(); + for (const scriptCov of scriptCovs) { + for (const funcCov of scriptCov.functions) { + const rootRange = stringifyFunctionRootRange(funcCov); + let funcCovs = rangeToFuncs.get(rootRange); + if (funcCovs === undefined || + // if the entry in rangeToFuncs is function-level granularity and + // the new coverage is block-level, prefer block-level. + (!funcCovs[0].isBlockCoverage && funcCov.isBlockCoverage)) { + funcCovs = []; + rangeToFuncs.set(rootRange, funcCovs); + } + else if (funcCovs[0].isBlockCoverage && !funcCov.isBlockCoverage) { + // if the entry in rangeToFuncs is block-level granularity, we should + // not append function level granularity. + continue; + } + funcCovs.push(funcCov); + } + } + const functions = []; + for (const funcCovs of rangeToFuncs.values()) { + // assert: `funcCovs.length > 0` + functions.push(mergeFunctionCovs(funcCovs)); + } + const merged = { scriptId, url, functions }; + normalizeScriptCov(merged); + return merged; +} +/** + * Returns a string representation of the root range of the function. + * + * This string can be used to match function with same root range. + * The string is derived from the start and end offsets of the root range of + * the function. + * This assumes that `ranges` is non-empty (true for valid function coverages). + * + * @param funcCov Function coverage with the range to stringify + * @internal + */ +function stringifyFunctionRootRange(funcCov) { + const rootRange = funcCov.ranges[0]; + return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`; +} +/** + * Merges a list of matching function coverages. + * + * Functions are matching if their root ranges have the same span. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param funcCovs Function coverages to merge. + * @return Merged function coverage, or `undefined` if the input list was empty. + */ +export function mergeFunctionCovs(funcCovs) { + if (funcCovs.length === 0) { + return undefined; + } + else if (funcCovs.length === 1) { + const merged = funcCovs[0]; + normalizeFunctionCov(merged); + return merged; + } + const functionName = funcCovs[0].functionName; + const trees = []; + for (const funcCov of funcCovs) { + // assert: `fn.ranges.length > 0` + // assert: `fn.ranges` is sorted + trees.push(RangeTree.fromSortedRanges(funcCov.ranges)); + } + // assert: `trees.length > 0` + const mergedTree = mergeRangeTrees(trees); + normalizeRangeTree(mergedTree); + const ranges = mergedTree.toRanges(); + const isBlockCoverage = !(ranges.length === 1 && ranges[0].count === 0); + const merged = { functionName, ranges, isBlockCoverage }; + // assert: `merged` is normalized + return merged; +} +/** + * @precondition Same `start` and `end` for all the trees + */ +function mergeRangeTrees(trees) { + if (trees.length <= 1) { + return trees[0]; + } + const first = trees[0]; + let delta = 0; + for (const tree of trees) { + delta += tree.delta; + } + const children = mergeRangeTreeChildren(trees); + return new RangeTree(first.start, first.end, delta, children); +} +class RangeTreeWithParent { + constructor(parentIndex, tree) { + this.parentIndex = parentIndex; + this.tree = tree; + } +} +class StartEvent { + constructor(offset, trees) { + this.offset = offset; + this.trees = trees; + } + static compare(a, b) { + return a.offset - b.offset; + } +} +class StartEventQueue { + constructor(queue) { + this.queue = queue; + this.nextIndex = 0; + this.pendingOffset = 0; + this.pendingTrees = undefined; + } + static fromParentTrees(parentTrees) { + const startToTrees = new Map(); + for (const [parentIndex, parentTree] of parentTrees.entries()) { + for (const child of parentTree.children) { + let trees = startToTrees.get(child.start); + if (trees === undefined) { + trees = []; + startToTrees.set(child.start, trees); + } + trees.push(new RangeTreeWithParent(parentIndex, child)); + } + } + const queue = []; + for (const [startOffset, trees] of startToTrees) { + queue.push(new StartEvent(startOffset, trees)); + } + queue.sort(StartEvent.compare); + return new StartEventQueue(queue); + } + setPendingOffset(offset) { + this.pendingOffset = offset; + } + pushPendingTree(tree) { + if (this.pendingTrees === undefined) { + this.pendingTrees = []; + } + this.pendingTrees.push(tree); + } + next() { + const pendingTrees = this.pendingTrees; + const nextEvent = this.queue[this.nextIndex]; + if (pendingTrees === undefined) { + this.nextIndex++; + return nextEvent; + } + else if (nextEvent === undefined) { + this.pendingTrees = undefined; + return new StartEvent(this.pendingOffset, pendingTrees); + } + else { + if (this.pendingOffset < nextEvent.offset) { + this.pendingTrees = undefined; + return new StartEvent(this.pendingOffset, pendingTrees); + } + else { + if (this.pendingOffset === nextEvent.offset) { + this.pendingTrees = undefined; + for (const tree of pendingTrees) { + nextEvent.trees.push(tree); + } + } + this.nextIndex++; + return nextEvent; + } + } + } +} +function mergeRangeTreeChildren(parentTrees) { + const result = []; + const startEventQueue = StartEventQueue.fromParentTrees(parentTrees); + const parentToNested = new Map(); + let openRange; + while (true) { + const event = startEventQueue.next(); + if (event === undefined) { + break; + } + if (openRange !== undefined && openRange.end <= event.offset) { + result.push(nextChild(openRange, parentToNested)); + openRange = undefined; + } + if (openRange === undefined) { + let openRangeEnd = event.offset + 1; + for (const { parentIndex, tree } of event.trees) { + openRangeEnd = Math.max(openRangeEnd, tree.end); + insertChild(parentToNested, parentIndex, tree); + } + startEventQueue.setPendingOffset(openRangeEnd); + openRange = { start: event.offset, end: openRangeEnd }; + } + else { + for (const { parentIndex, tree } of event.trees) { + if (tree.end > openRange.end) { + const right = tree.split(openRange.end); + startEventQueue.pushPendingTree(new RangeTreeWithParent(parentIndex, right)); + } + insertChild(parentToNested, parentIndex, tree); + } + } + } + if (openRange !== undefined) { + result.push(nextChild(openRange, parentToNested)); + } + return result; +} +function insertChild(parentToNested, parentIndex, tree) { + let nested = parentToNested.get(parentIndex); + if (nested === undefined) { + nested = []; + parentToNested.set(parentIndex, nested); + } + nested.push(tree); +} +function nextChild(openRange, parentToNested) { + const matchingTrees = []; + for (const nested of parentToNested.values()) { + if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) { + matchingTrees.push(nested[0]); + } + else { + matchingTrees.push(new RangeTree(openRange.start, openRange.end, 0, nested)); + } + } + parentToNested.clear(); + return mergeRangeTrees(matchingTrees); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/merge.ts"],"names":[],"mappings":"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","file":"merge.js","sourcesContent":["import {\n  deepNormalizeScriptCov,\n  normalizeFunctionCov,\n  normalizeProcessCov,\n  normalizeRangeTree,\n  normalizeScriptCov,\n} from \"./normalize\";\nimport { RangeTree } from \"./range-tree\";\nimport { FunctionCov, ProcessCov, Range, RangeCov, ScriptCov } from \"./types\";\n\n/**\n * Merges a list of process coverages.\n *\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param processCovs Process coverages to merge.\n * @return Merged process coverage.\n */\nexport function mergeProcessCovs(processCovs: ReadonlyArray<ProcessCov>): ProcessCov {\n  if (processCovs.length === 0) {\n    return {result: []};\n  }\n\n  const urlToScripts: Map<string, ScriptCov[]> = new Map();\n  for (const processCov of processCovs) {\n    for (const scriptCov of processCov.result) {\n      let scriptCovs: ScriptCov[] | undefined = urlToScripts.get(scriptCov.url);\n      if (scriptCovs === undefined) {\n        scriptCovs = [];\n        urlToScripts.set(scriptCov.url, scriptCovs);\n      }\n      scriptCovs.push(scriptCov);\n    }\n  }\n\n  const result: ScriptCov[] = [];\n  for (const scripts of urlToScripts.values()) {\n    // assert: `scripts.length > 0`\n    result.push(mergeScriptCovs(scripts)!);\n  }\n  const merged: ProcessCov = {result};\n\n  normalizeProcessCov(merged);\n  return merged;\n}\n\n/**\n * Merges a list of matching script coverages.\n *\n * Scripts are matching if they have the same `url`.\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param scriptCovs Process coverages to merge.\n * @return Merged script coverage, or `undefined` if the input list was empty.\n */\nexport function mergeScriptCovs(scriptCovs: ReadonlyArray<ScriptCov>): ScriptCov | undefined {\n  if (scriptCovs.length === 0) {\n    return undefined;\n  } else if (scriptCovs.length === 1) {\n    const merged: ScriptCov = scriptCovs[0];\n    deepNormalizeScriptCov(merged);\n    return merged;\n  }\n\n  const first: ScriptCov = scriptCovs[0];\n  const scriptId: string = first.scriptId;\n  const url: string = first.url;\n\n  const rangeToFuncs: Map<string, FunctionCov[]> = new Map();\n  for (const scriptCov of scriptCovs) {\n    for (const funcCov of scriptCov.functions) {\n      const rootRange: string = stringifyFunctionRootRange(funcCov);\n      let funcCovs: FunctionCov[] | undefined = rangeToFuncs.get(rootRange);\n\n      if (funcCovs === undefined ||\n        // if the entry in rangeToFuncs is function-level granularity and\n        // the new coverage is block-level, prefer block-level.\n        (!funcCovs[0].isBlockCoverage && funcCov.isBlockCoverage)) {\n        funcCovs = [];\n        rangeToFuncs.set(rootRange, funcCovs);\n      } else if (funcCovs[0].isBlockCoverage && !funcCov.isBlockCoverage) {\n        // if the entry in rangeToFuncs is block-level granularity, we should\n        // not append function level granularity.\n        continue;\n      }\n      funcCovs.push(funcCov);\n    }\n  }\n\n  const functions: FunctionCov[] = [];\n  for (const funcCovs of rangeToFuncs.values()) {\n    // assert: `funcCovs.length > 0`\n    functions.push(mergeFunctionCovs(funcCovs)!);\n  }\n\n  const merged: ScriptCov = {scriptId, url, functions};\n  normalizeScriptCov(merged);\n  return merged;\n}\n\n/**\n * Returns a string representation of the root range of the function.\n *\n * This string can be used to match function with same root range.\n * The string is derived from the start and end offsets of the root range of\n * the function.\n * This assumes that `ranges` is non-empty (true for valid function coverages).\n *\n * @param funcCov Function coverage with the range to stringify\n * @internal\n */\nfunction stringifyFunctionRootRange(funcCov: Readonly<FunctionCov>): string {\n  const rootRange: RangeCov = funcCov.ranges[0];\n  return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`;\n}\n\n/**\n * Merges a list of matching function coverages.\n *\n * Functions are matching if their root ranges have the same span.\n * The result is normalized.\n * The input values may be mutated, it is not safe to use them after passing\n * them to this function.\n * The computation is synchronous.\n *\n * @param funcCovs Function coverages to merge.\n * @return Merged function coverage, or `undefined` if the input list was empty.\n */\nexport function mergeFunctionCovs(funcCovs: ReadonlyArray<FunctionCov>): FunctionCov | undefined {\n  if (funcCovs.length === 0) {\n    return undefined;\n  } else if (funcCovs.length === 1) {\n    const merged: FunctionCov = funcCovs[0];\n    normalizeFunctionCov(merged);\n    return merged;\n  }\n\n  const functionName: string = funcCovs[0].functionName;\n\n  const trees: RangeTree[] = [];\n  for (const funcCov of funcCovs) {\n    // assert: `fn.ranges.length > 0`\n    // assert: `fn.ranges` is sorted\n    trees.push(RangeTree.fromSortedRanges(funcCov.ranges)!);\n  }\n\n  // assert: `trees.length > 0`\n  const mergedTree: RangeTree = mergeRangeTrees(trees)!;\n  normalizeRangeTree(mergedTree);\n  const ranges: RangeCov[] = mergedTree.toRanges();\n  const isBlockCoverage: boolean = !(ranges.length === 1 && ranges[0].count === 0);\n\n  const merged: FunctionCov = {functionName, ranges, isBlockCoverage};\n  // assert: `merged` is normalized\n  return merged;\n}\n\n/**\n * @precondition Same `start` and `end` for all the trees\n */\nfunction mergeRangeTrees(trees: ReadonlyArray<RangeTree>): RangeTree | undefined {\n  if (trees.length <= 1) {\n    return trees[0];\n  }\n  const first: RangeTree = trees[0];\n  let delta: number = 0;\n  for (const tree of trees) {\n    delta += tree.delta;\n  }\n  const children: RangeTree[] = mergeRangeTreeChildren(trees);\n  return new RangeTree(first.start, first.end, delta, children);\n}\n\nclass RangeTreeWithParent {\n  readonly parentIndex: number;\n  readonly tree: RangeTree;\n\n  constructor(parentIndex: number, tree: RangeTree) {\n    this.parentIndex = parentIndex;\n    this.tree = tree;\n  }\n}\n\nclass StartEvent {\n  readonly offset: number;\n  readonly trees: RangeTreeWithParent[];\n\n  constructor(offset: number, trees: RangeTreeWithParent[]) {\n    this.offset = offset;\n    this.trees = trees;\n  }\n\n  static compare(a: StartEvent, b: StartEvent): number {\n    return a.offset - b.offset;\n  }\n}\n\nclass StartEventQueue {\n  private readonly queue: StartEvent[];\n  private nextIndex: number;\n  private pendingOffset: number;\n  private pendingTrees: RangeTreeWithParent[] | undefined;\n\n  private constructor(queue: StartEvent[]) {\n    this.queue = queue;\n    this.nextIndex = 0;\n    this.pendingOffset = 0;\n    this.pendingTrees = undefined;\n  }\n\n  static fromParentTrees(parentTrees: ReadonlyArray<RangeTree>): StartEventQueue {\n    const startToTrees: Map<number, RangeTreeWithParent[]> = new Map();\n    for (const [parentIndex, parentTree] of parentTrees.entries()) {\n      for (const child of parentTree.children) {\n        let trees: RangeTreeWithParent[] | undefined = startToTrees.get(child.start);\n        if (trees === undefined) {\n          trees = [];\n          startToTrees.set(child.start, trees);\n        }\n        trees.push(new RangeTreeWithParent(parentIndex, child));\n      }\n    }\n    const queue: StartEvent[] = [];\n    for (const [startOffset, trees] of startToTrees) {\n      queue.push(new StartEvent(startOffset, trees));\n    }\n    queue.sort(StartEvent.compare);\n    return new StartEventQueue(queue);\n  }\n\n  setPendingOffset(offset: number): void {\n    this.pendingOffset = offset;\n  }\n\n  pushPendingTree(tree: RangeTreeWithParent): void {\n    if (this.pendingTrees === undefined) {\n      this.pendingTrees = [];\n    }\n    this.pendingTrees.push(tree);\n  }\n\n  next(): StartEvent | undefined {\n    const pendingTrees: RangeTreeWithParent[] | undefined = this.pendingTrees;\n    const nextEvent: StartEvent | undefined = this.queue[this.nextIndex];\n    if (pendingTrees === undefined) {\n      this.nextIndex++;\n      return nextEvent;\n    } else if (nextEvent === undefined) {\n      this.pendingTrees = undefined;\n      return new StartEvent(this.pendingOffset, pendingTrees);\n    } else {\n      if (this.pendingOffset < nextEvent.offset) {\n        this.pendingTrees = undefined;\n        return new StartEvent(this.pendingOffset, pendingTrees);\n      } else {\n        if (this.pendingOffset === nextEvent.offset) {\n          this.pendingTrees = undefined;\n          for (const tree of pendingTrees) {\n            nextEvent.trees.push(tree);\n          }\n        }\n        this.nextIndex++;\n        return nextEvent;\n      }\n    }\n  }\n}\n\nfunction mergeRangeTreeChildren(parentTrees: ReadonlyArray<RangeTree>): RangeTree[] {\n  const result: RangeTree[] = [];\n  const startEventQueue: StartEventQueue = StartEventQueue.fromParentTrees(parentTrees);\n  const parentToNested: Map<number, RangeTree[]> = new Map();\n  let openRange: Range | undefined;\n\n  while (true) {\n    const event: StartEvent | undefined = startEventQueue.next();\n    if (event === undefined) {\n      break;\n    }\n\n    if (openRange !== undefined && openRange.end <= event.offset) {\n      result.push(nextChild(openRange, parentToNested));\n      openRange = undefined;\n    }\n\n    if (openRange === undefined) {\n      let openRangeEnd: number = event.offset + 1;\n      for (const {parentIndex, tree} of event.trees) {\n        openRangeEnd = Math.max(openRangeEnd, tree.end);\n        insertChild(parentToNested, parentIndex, tree);\n      }\n      startEventQueue.setPendingOffset(openRangeEnd);\n      openRange = {start: event.offset, end: openRangeEnd};\n    } else {\n      for (const {parentIndex, tree} of event.trees) {\n        if (tree.end > openRange.end) {\n          const right: RangeTree = tree.split(openRange.end);\n          startEventQueue.pushPendingTree(new RangeTreeWithParent(parentIndex, right));\n        }\n        insertChild(parentToNested, parentIndex, tree);\n      }\n    }\n  }\n  if (openRange !== undefined) {\n    result.push(nextChild(openRange, parentToNested));\n  }\n\n  return result;\n}\n\nfunction insertChild(parentToNested: Map<number, RangeTree[]>, parentIndex: number, tree: RangeTree): void {\n  let nested: RangeTree[] | undefined = parentToNested.get(parentIndex);\n  if (nested === undefined) {\n    nested = [];\n    parentToNested.set(parentIndex, nested);\n  }\n  nested.push(tree);\n}\n\nfunction nextChild(openRange: Range, parentToNested: Map<number, RangeTree[]>): RangeTree {\n  const matchingTrees: RangeTree[] = [];\n\n  for (const nested of parentToNested.values()) {\n    if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) {\n      matchingTrees.push(nested[0]);\n    } else {\n      matchingTrees.push(new RangeTree(\n        openRange.start,\n        openRange.end,\n        0,\n        nested,\n      ));\n    }\n  }\n  parentToNested.clear();\n  return mergeRangeTrees(matchingTrees)!;\n}\n"],"sourceRoot":""} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.d.ts new file mode 100644 index 00000000000..db9f0f8f482 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.d.ts @@ -0,0 +1,53 @@ +import { RangeTree } from "./range-tree"; +import { FunctionCov, ProcessCov, ScriptCov } from "./types"; +/** + * Normalizes a process coverage. + * + * Sorts the scripts alphabetically by `url`. + * Reassigns script ids: the script at index `0` receives `"0"`, the script at + * index `1` receives `"1"` etc. + * This does not normalize the script coverages. + * + * @param processCov Process coverage to normalize. + */ +export declare function normalizeProcessCov(processCov: ProcessCov): void; +/** + * Normalizes a process coverage deeply. + * + * Normalizes the script coverages deeply, then normalizes the process coverage + * itself. + * + * @param processCov Process coverage to normalize. + */ +export declare function deepNormalizeProcessCov(processCov: ProcessCov): void; +/** + * Normalizes a script coverage. + * + * Sorts the function by root range (pre-order sort). + * This does not normalize the function coverages. + * + * @param scriptCov Script coverage to normalize. + */ +export declare function normalizeScriptCov(scriptCov: ScriptCov): void; +/** + * Normalizes a script coverage deeply. + * + * Normalizes the function coverages deeply, then normalizes the script coverage + * itself. + * + * @param scriptCov Script coverage to normalize. + */ +export declare function deepNormalizeScriptCov(scriptCov: ScriptCov): void; +/** + * Normalizes a function coverage. + * + * Sorts the ranges (pre-order sort). + * TODO: Tree-based normalization of the ranges. + * + * @param funcCov Function coverage to normalize. + */ +export declare function normalizeFunctionCov(funcCov: FunctionCov): void; +/** + * @internal + */ +export declare function normalizeRangeTree(tree: RangeTree): void; diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.js new file mode 100644 index 00000000000..92df2b6fb09 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.js @@ -0,0 +1,87 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const compare_1 = require("./compare"); +const range_tree_1 = require("./range-tree"); +/** + * Normalizes a process coverage. + * + * Sorts the scripts alphabetically by `url`. + * Reassigns script ids: the script at index `0` receives `"0"`, the script at + * index `1` receives `"1"` etc. + * This does not normalize the script coverages. + * + * @param processCov Process coverage to normalize. + */ +function normalizeProcessCov(processCov) { + processCov.result.sort(compare_1.compareScriptCovs); + for (const [scriptId, scriptCov] of processCov.result.entries()) { + scriptCov.scriptId = scriptId.toString(10); + } +} +exports.normalizeProcessCov = normalizeProcessCov; +/** + * Normalizes a process coverage deeply. + * + * Normalizes the script coverages deeply, then normalizes the process coverage + * itself. + * + * @param processCov Process coverage to normalize. + */ +function deepNormalizeProcessCov(processCov) { + for (const scriptCov of processCov.result) { + deepNormalizeScriptCov(scriptCov); + } + normalizeProcessCov(processCov); +} +exports.deepNormalizeProcessCov = deepNormalizeProcessCov; +/** + * Normalizes a script coverage. + * + * Sorts the function by root range (pre-order sort). + * This does not normalize the function coverages. + * + * @param scriptCov Script coverage to normalize. + */ +function normalizeScriptCov(scriptCov) { + scriptCov.functions.sort(compare_1.compareFunctionCovs); +} +exports.normalizeScriptCov = normalizeScriptCov; +/** + * Normalizes a script coverage deeply. + * + * Normalizes the function coverages deeply, then normalizes the script coverage + * itself. + * + * @param scriptCov Script coverage to normalize. + */ +function deepNormalizeScriptCov(scriptCov) { + for (const funcCov of scriptCov.functions) { + normalizeFunctionCov(funcCov); + } + normalizeScriptCov(scriptCov); +} +exports.deepNormalizeScriptCov = deepNormalizeScriptCov; +/** + * Normalizes a function coverage. + * + * Sorts the ranges (pre-order sort). + * TODO: Tree-based normalization of the ranges. + * + * @param funcCov Function coverage to normalize. + */ +function normalizeFunctionCov(funcCov) { + funcCov.ranges.sort(compare_1.compareRangeCovs); + const tree = range_tree_1.RangeTree.fromSortedRanges(funcCov.ranges); + normalizeRangeTree(tree); + funcCov.ranges = tree.toRanges(); +} +exports.normalizeFunctionCov = normalizeFunctionCov; +/** + * @internal + */ +function normalizeRangeTree(tree) { + tree.normalize(); +} +exports.normalizeRangeTree = normalizeRangeTree; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.mjs new file mode 100644 index 00000000000..2c477eb0f53 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/normalize.mjs @@ -0,0 +1,79 @@ +import { compareFunctionCovs, compareRangeCovs, compareScriptCovs } from "./compare"; +import { RangeTree } from "./range-tree"; +/** + * Normalizes a process coverage. + * + * Sorts the scripts alphabetically by `url`. + * Reassigns script ids: the script at index `0` receives `"0"`, the script at + * index `1` receives `"1"` etc. + * This does not normalize the script coverages. + * + * @param processCov Process coverage to normalize. + */ +export function normalizeProcessCov(processCov) { + processCov.result.sort(compareScriptCovs); + for (const [scriptId, scriptCov] of processCov.result.entries()) { + scriptCov.scriptId = scriptId.toString(10); + } +} +/** + * Normalizes a process coverage deeply. + * + * Normalizes the script coverages deeply, then normalizes the process coverage + * itself. + * + * @param processCov Process coverage to normalize. + */ +export function deepNormalizeProcessCov(processCov) { + for (const scriptCov of processCov.result) { + deepNormalizeScriptCov(scriptCov); + } + normalizeProcessCov(processCov); +} +/** + * Normalizes a script coverage. + * + * Sorts the function by root range (pre-order sort). + * This does not normalize the function coverages. + * + * @param scriptCov Script coverage to normalize. + */ +export function normalizeScriptCov(scriptCov) { + scriptCov.functions.sort(compareFunctionCovs); +} +/** + * Normalizes a script coverage deeply. + * + * Normalizes the function coverages deeply, then normalizes the script coverage + * itself. + * + * @param scriptCov Script coverage to normalize. + */ +export function deepNormalizeScriptCov(scriptCov) { + for (const funcCov of scriptCov.functions) { + normalizeFunctionCov(funcCov); + } + normalizeScriptCov(scriptCov); +} +/** + * Normalizes a function coverage. + * + * Sorts the ranges (pre-order sort). + * TODO: Tree-based normalization of the ranges. + * + * @param funcCov Function coverage to normalize. + */ +export function normalizeFunctionCov(funcCov) { + funcCov.ranges.sort(compareRangeCovs); + const tree = RangeTree.fromSortedRanges(funcCov.ranges); + normalizeRangeTree(tree); + funcCov.ranges = tree.toRanges(); +} +/** + * @internal + */ +export function normalizeRangeTree(tree) { + tree.normalize(); +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,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 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/package.json b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/package.json new file mode 100644 index 00000000000..d81b33cfd4c --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/package.json @@ -0,0 +1,44 @@ +{ + "name": "@bcoe/v8-coverage", + "version": "0.2.3", + "description": "Helper functions for V8 coverage files.", + "author": "Charles Samborski (https://demurgos.net)", + "license": "MIT", + "main": "index", + "types": "index.d.ts", + "repository": { + "type": "git", + "url": "git://github.com/demurgos/v8-coverage.git" + }, + "homepage": "https://demurgos.github.io/v8-coverage", + "devDependencies": { + "@types/chai": "^4.1.4", + "@types/gulp": "^4.0.5", + "@types/minimist": "^1.2.0", + "@types/mocha": "^5.2.2", + "@types/node": "^10.5.4", + "chai": "^4.1.2", + "codecov": "^3.0.2", + "gulp": "^4.0.0", + "gulp-cli": "^2.0.1", + "minimist": "^1.2.0", + "pre-commit": "^1.2.2", + "ts-node": "^8.3.0", + "turbo-gulp": "^0.20.1" + }, + "nyc": { + "include": [ + "build/test/lib/**/*.js", + "build/test/lib/**/*.mjs" + ], + "reporter": [ + "text", + "html" + ], + "extension": [ + ".mjs" + ] + }, + "gitHead": "529387e2bd3e0ba0b9336d80ec563aee593331e1", + "private": false +} \ No newline at end of file diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.d.ts new file mode 100644 index 00000000000..f7e18e87d62 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.d.ts @@ -0,0 +1,24 @@ +import { RangeCov } from "./types"; +export declare class RangeTree { + start: number; + end: number; + delta: number; + children: RangeTree[]; + constructor(start: number, end: number, delta: number, children: RangeTree[]); + /** + * @precodition `ranges` are well-formed and pre-order sorted + */ + static fromSortedRanges(ranges: ReadonlyArray): RangeTree | undefined; + normalize(): void; + /** + * @precondition `tree.start < value && value < tree.end` + * @return RangeTree Right part + */ + split(value: number): RangeTree; + /** + * Get the range coverages corresponding to the tree. + * + * The ranges are pre-order sorted. + */ + toRanges(): RangeCov[]; +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.js new file mode 100644 index 00000000000..f392cf19514 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.js @@ -0,0 +1,139 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +class RangeTree { + constructor(start, end, delta, children) { + this.start = start; + this.end = end; + this.delta = delta; + this.children = children; + } + /** + * @precodition `ranges` are well-formed and pre-order sorted + */ + static fromSortedRanges(ranges) { + let root; + // Stack of parent trees and parent counts. + const stack = []; + for (const range of ranges) { + const node = new RangeTree(range.startOffset, range.endOffset, range.count, []); + if (root === undefined) { + root = node; + stack.push([node, range.count]); + continue; + } + let parent; + let parentCount; + while (true) { + [parent, parentCount] = stack[stack.length - 1]; + // assert: `top !== undefined` (the ranges are sorted) + if (range.startOffset < parent.end) { + break; + } + else { + stack.pop(); + } + } + node.delta -= parentCount; + parent.children.push(node); + stack.push([node, range.count]); + } + return root; + } + normalize() { + const children = []; + let curEnd; + let head; + const tail = []; + for (const child of this.children) { + if (head === undefined) { + head = child; + } + else if (child.delta === head.delta && child.start === curEnd) { + tail.push(child); + } + else { + endChain(); + head = child; + } + curEnd = child.end; + } + if (head !== undefined) { + endChain(); + } + if (children.length === 1) { + const child = children[0]; + if (child.start === this.start && child.end === this.end) { + this.delta += child.delta; + this.children = child.children; + // `.lazyCount` is zero for both (both are after normalization) + return; + } + } + this.children = children; + function endChain() { + if (tail.length !== 0) { + head.end = tail[tail.length - 1].end; + for (const tailTree of tail) { + for (const subChild of tailTree.children) { + subChild.delta += tailTree.delta - head.delta; + head.children.push(subChild); + } + } + tail.length = 0; + } + head.normalize(); + children.push(head); + } + } + /** + * @precondition `tree.start < value && value < tree.end` + * @return RangeTree Right part + */ + split(value) { + let leftChildLen = this.children.length; + let mid; + // TODO(perf): Binary search (check overhead) + for (let i = 0; i < this.children.length; i++) { + const child = this.children[i]; + if (child.start < value && value < child.end) { + mid = child.split(value); + leftChildLen = i + 1; + break; + } + else if (child.start >= value) { + leftChildLen = i; + break; + } + } + const rightLen = this.children.length - leftChildLen; + const rightChildren = this.children.splice(leftChildLen, rightLen); + if (mid !== undefined) { + rightChildren.unshift(mid); + } + const result = new RangeTree(value, this.end, this.delta, rightChildren); + this.end = value; + return result; + } + /** + * Get the range coverages corresponding to the tree. + * + * The ranges are pre-order sorted. + */ + toRanges() { + const ranges = []; + // Stack of parent trees and counts. + const stack = [[this, 0]]; + while (stack.length > 0) { + const [cur, parentCount] = stack.pop(); + const count = parentCount + cur.delta; + ranges.push({ startOffset: cur.start, endOffset: cur.end, count }); + for (let i = cur.children.length - 1; i >= 0; i--) { + stack.push([cur.children[i], count]); + } + } + return ranges; + } +} +exports.RangeTree = RangeTree; + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/range-tree.ts"],"names":[],"mappings":"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","file":"range-tree.js","sourcesContent":["import { RangeCov } from \"./types\";\n\nexport class RangeTree {\n  start: number;\n  end: number;\n  delta: number;\n  children: RangeTree[];\n\n  constructor(\n    start: number,\n    end: number,\n    delta: number,\n    children: RangeTree[],\n  ) {\n    this.start = start;\n    this.end = end;\n    this.delta = delta;\n    this.children = children;\n  }\n\n  /**\n   * @precodition `ranges` are well-formed and pre-order sorted\n   */\n  static fromSortedRanges(ranges: ReadonlyArray<RangeCov>): RangeTree | undefined {\n    let root: RangeTree | undefined;\n    // Stack of parent trees and parent counts.\n    const stack: [RangeTree, number][] = [];\n    for (const range of ranges) {\n      const node: RangeTree = new RangeTree(range.startOffset, range.endOffset, range.count, []);\n      if (root === undefined) {\n        root = node;\n        stack.push([node, range.count]);\n        continue;\n      }\n      let parent: RangeTree;\n      let parentCount: number;\n      while (true) {\n        [parent, parentCount] = stack[stack.length - 1];\n        // assert: `top !== undefined` (the ranges are sorted)\n        if (range.startOffset < parent.end) {\n          break;\n        } else {\n          stack.pop();\n        }\n      }\n      node.delta -= parentCount;\n      parent.children.push(node);\n      stack.push([node, range.count]);\n    }\n    return root;\n  }\n\n  normalize(): void {\n    const children: RangeTree[] = [];\n    let curEnd: number;\n    let head: RangeTree | undefined;\n    const tail: RangeTree[] = [];\n    for (const child of this.children) {\n      if (head === undefined) {\n        head = child;\n      } else if (child.delta === head.delta && child.start === curEnd!) {\n        tail.push(child);\n      } else {\n        endChain();\n        head = child;\n      }\n      curEnd = child.end;\n    }\n    if (head !== undefined) {\n      endChain();\n    }\n\n    if (children.length === 1) {\n      const child: RangeTree = children[0];\n      if (child.start === this.start && child.end === this.end) {\n        this.delta += child.delta;\n        this.children = child.children;\n        // `.lazyCount` is zero for both (both are after normalization)\n        return;\n      }\n    }\n\n    this.children = children;\n\n    function endChain(): void {\n      if (tail.length !== 0) {\n        head!.end = tail[tail.length - 1].end;\n        for (const tailTree of tail) {\n          for (const subChild of tailTree.children) {\n            subChild.delta += tailTree.delta - head!.delta;\n            head!.children.push(subChild);\n          }\n        }\n        tail.length = 0;\n      }\n      head!.normalize();\n      children.push(head!);\n    }\n  }\n\n  /**\n   * @precondition `tree.start < value && value < tree.end`\n   * @return RangeTree Right part\n   */\n  split(value: number): RangeTree {\n    let leftChildLen: number = this.children.length;\n    let mid: RangeTree | undefined;\n\n    // TODO(perf): Binary search (check overhead)\n    for (let i: number = 0; i < this.children.length; i++) {\n      const child: RangeTree = this.children[i];\n      if (child.start < value && value < child.end) {\n        mid = child.split(value);\n        leftChildLen = i + 1;\n        break;\n      } else if (child.start >= value) {\n        leftChildLen = i;\n        break;\n      }\n    }\n\n    const rightLen: number = this.children.length - leftChildLen;\n    const rightChildren: RangeTree[] = this.children.splice(leftChildLen, rightLen);\n    if (mid !== undefined) {\n      rightChildren.unshift(mid);\n    }\n    const result: RangeTree = new RangeTree(\n      value,\n      this.end,\n      this.delta,\n      rightChildren,\n    );\n    this.end = value;\n    return result;\n  }\n\n  /**\n   * Get the range coverages corresponding to the tree.\n   *\n   * The ranges are pre-order sorted.\n   */\n  toRanges(): RangeCov[] {\n    const ranges: RangeCov[] = [];\n    // Stack of parent trees and counts.\n    const stack: [RangeTree, number][] = [[this, 0]];\n    while (stack.length > 0) {\n      const [cur, parentCount]: [RangeTree, number] = stack.pop()!;\n      const count: number = parentCount + cur.delta;\n      ranges.push({startOffset: cur.start, endOffset: cur.end, count});\n      for (let i: number = cur.children.length - 1; i >= 0; i--) {\n        stack.push([cur.children[i], count]);\n      }\n    }\n    return ranges;\n  }\n}\n"],"sourceRoot":""} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.mjs new file mode 100644 index 00000000000..73f13dd9f5d --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/range-tree.mjs @@ -0,0 +1,136 @@ +export class RangeTree { + constructor(start, end, delta, children) { + this.start = start; + this.end = end; + this.delta = delta; + this.children = children; + } + /** + * @precodition `ranges` are well-formed and pre-order sorted + */ + static fromSortedRanges(ranges) { + let root; + // Stack of parent trees and parent counts. + const stack = []; + for (const range of ranges) { + const node = new RangeTree(range.startOffset, range.endOffset, range.count, []); + if (root === undefined) { + root = node; + stack.push([node, range.count]); + continue; + } + let parent; + let parentCount; + while (true) { + [parent, parentCount] = stack[stack.length - 1]; + // assert: `top !== undefined` (the ranges are sorted) + if (range.startOffset < parent.end) { + break; + } + else { + stack.pop(); + } + } + node.delta -= parentCount; + parent.children.push(node); + stack.push([node, range.count]); + } + return root; + } + normalize() { + const children = []; + let curEnd; + let head; + const tail = []; + for (const child of this.children) { + if (head === undefined) { + head = child; + } + else if (child.delta === head.delta && child.start === curEnd) { + tail.push(child); + } + else { + endChain(); + head = child; + } + curEnd = child.end; + } + if (head !== undefined) { + endChain(); + } + if (children.length === 1) { + const child = children[0]; + if (child.start === this.start && child.end === this.end) { + this.delta += child.delta; + this.children = child.children; + // `.lazyCount` is zero for both (both are after normalization) + return; + } + } + this.children = children; + function endChain() { + if (tail.length !== 0) { + head.end = tail[tail.length - 1].end; + for (const tailTree of tail) { + for (const subChild of tailTree.children) { + subChild.delta += tailTree.delta - head.delta; + head.children.push(subChild); + } + } + tail.length = 0; + } + head.normalize(); + children.push(head); + } + } + /** + * @precondition `tree.start < value && value < tree.end` + * @return RangeTree Right part + */ + split(value) { + let leftChildLen = this.children.length; + let mid; + // TODO(perf): Binary search (check overhead) + for (let i = 0; i < this.children.length; i++) { + const child = this.children[i]; + if (child.start < value && value < child.end) { + mid = child.split(value); + leftChildLen = i + 1; + break; + } + else if (child.start >= value) { + leftChildLen = i; + break; + } + } + const rightLen = this.children.length - leftChildLen; + const rightChildren = this.children.splice(leftChildLen, rightLen); + if (mid !== undefined) { + rightChildren.unshift(mid); + } + const result = new RangeTree(value, this.end, this.delta, rightChildren); + this.end = value; + return result; + } + /** + * Get the range coverages corresponding to the tree. + * + * The ranges are pre-order sorted. + */ + toRanges() { + const ranges = []; + // Stack of parent trees and counts. + const stack = [[this, 0]]; + while (stack.length > 0) { + const [cur, parentCount] = stack.pop(); + const count = parentCount + cur.delta; + ranges.push({ startOffset: cur.start, endOffset: cur.end, count }); + for (let i = cur.children.length - 1; i >= 0; i--) { + stack.push([cur.children[i], count]); + } + } + return ranges; + } +} + +//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["_src/range-tree.ts"],"names":[],"mappings":"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","file":"range-tree.js","sourcesContent":["import { RangeCov } from \"./types\";\n\nexport class RangeTree {\n  start: number;\n  end: number;\n  delta: number;\n  children: RangeTree[];\n\n  constructor(\n    start: number,\n    end: number,\n    delta: number,\n    children: RangeTree[],\n  ) {\n    this.start = start;\n    this.end = end;\n    this.delta = delta;\n    this.children = children;\n  }\n\n  /**\n   * @precodition `ranges` are well-formed and pre-order sorted\n   */\n  static fromSortedRanges(ranges: ReadonlyArray<RangeCov>): RangeTree | undefined {\n    let root: RangeTree | undefined;\n    // Stack of parent trees and parent counts.\n    const stack: [RangeTree, number][] = [];\n    for (const range of ranges) {\n      const node: RangeTree = new RangeTree(range.startOffset, range.endOffset, range.count, []);\n      if (root === undefined) {\n        root = node;\n        stack.push([node, range.count]);\n        continue;\n      }\n      let parent: RangeTree;\n      let parentCount: number;\n      while (true) {\n        [parent, parentCount] = stack[stack.length - 1];\n        // assert: `top !== undefined` (the ranges are sorted)\n        if (range.startOffset < parent.end) {\n          break;\n        } else {\n          stack.pop();\n        }\n      }\n      node.delta -= parentCount;\n      parent.children.push(node);\n      stack.push([node, range.count]);\n    }\n    return root;\n  }\n\n  normalize(): void {\n    const children: RangeTree[] = [];\n    let curEnd: number;\n    let head: RangeTree | undefined;\n    const tail: RangeTree[] = [];\n    for (const child of this.children) {\n      if (head === undefined) {\n        head = child;\n      } else if (child.delta === head.delta && child.start === curEnd!) {\n        tail.push(child);\n      } else {\n        endChain();\n        head = child;\n      }\n      curEnd = child.end;\n    }\n    if (head !== undefined) {\n      endChain();\n    }\n\n    if (children.length === 1) {\n      const child: RangeTree = children[0];\n      if (child.start === this.start && child.end === this.end) {\n        this.delta += child.delta;\n        this.children = child.children;\n        // `.lazyCount` is zero for both (both are after normalization)\n        return;\n      }\n    }\n\n    this.children = children;\n\n    function endChain(): void {\n      if (tail.length !== 0) {\n        head!.end = tail[tail.length - 1].end;\n        for (const tailTree of tail) {\n          for (const subChild of tailTree.children) {\n            subChild.delta += tailTree.delta - head!.delta;\n            head!.children.push(subChild);\n          }\n        }\n        tail.length = 0;\n      }\n      head!.normalize();\n      children.push(head!);\n    }\n  }\n\n  /**\n   * @precondition `tree.start < value && value < tree.end`\n   * @return RangeTree Right part\n   */\n  split(value: number): RangeTree {\n    let leftChildLen: number = this.children.length;\n    let mid: RangeTree | undefined;\n\n    // TODO(perf): Binary search (check overhead)\n    for (let i: number = 0; i < this.children.length; i++) {\n      const child: RangeTree = this.children[i];\n      if (child.start < value && value < child.end) {\n        mid = child.split(value);\n        leftChildLen = i + 1;\n        break;\n      } else if (child.start >= value) {\n        leftChildLen = i;\n        break;\n      }\n    }\n\n    const rightLen: number = this.children.length - leftChildLen;\n    const rightChildren: RangeTree[] = this.children.splice(leftChildLen, rightLen);\n    if (mid !== undefined) {\n      rightChildren.unshift(mid);\n    }\n    const result: RangeTree = new RangeTree(\n      value,\n      this.end,\n      this.delta,\n      rightChildren,\n    );\n    this.end = value;\n    return result;\n  }\n\n  /**\n   * Get the range coverages corresponding to the tree.\n   *\n   * The ranges are pre-order sorted.\n   */\n  toRanges(): RangeCov[] {\n    const ranges: RangeCov[] = [];\n    // Stack of parent trees and counts.\n    const stack: [RangeTree, number][] = [[this, 0]];\n    while (stack.length > 0) {\n      const [cur, parentCount]: [RangeTree, number] = stack.pop()!;\n      const count: number = parentCount + cur.delta;\n      ranges.push({startOffset: cur.start, endOffset: cur.end, count});\n      for (let i: number = cur.children.length - 1; i >= 0; i--) {\n        stack.push([cur.children[i], count]);\n      }\n    }\n    return ranges;\n  }\n}\n"],"sourceRoot":""} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/tsconfig.json b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/tsconfig.json new file mode 100644 index 00000000000..aff36e90d5d --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/tsconfig.json @@ -0,0 +1,62 @@ +{ + "compilerOptions": { + "allowJs": false, + "allowSyntheticDefaultImports": true, + "allowUnreachableCode": false, + "allowUnusedLabels": false, + "alwaysStrict": true, + "charset": "utf8", + "checkJs": false, + "declaration": true, + "disableSizeLimit": false, + "downlevelIteration": false, + "emitBOM": false, + "emitDecoratorMetadata": true, + "esModuleInterop": true, + "experimentalDecorators": true, + "forceConsistentCasingInFileNames": true, + "importHelpers": false, + "inlineSourceMap": false, + "inlineSources": false, + "isolatedModules": false, + "lib": [ + "es2017", + "esnext.asynciterable" + ], + "locale": "en-us", + "module": "commonjs", + "moduleResolution": "node", + "newLine": "lf", + "noEmit": false, + "noEmitHelpers": false, + "noEmitOnError": true, + "noErrorTruncation": true, + "noFallthroughCasesInSwitch": true, + "noImplicitAny": true, + "noImplicitReturns": true, + "noImplicitThis": true, + "noStrictGenericChecks": false, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noImplicitUseStrict": false, + "noLib": false, + "noResolve": false, + "preserveConstEnums": true, + "removeComments": false, + "skipLibCheck": true, + "sourceMap": true, + "strict": true, + "strictNullChecks": true, + "suppressExcessPropertyErrors": false, + "suppressImplicitAnyIndexErrors": false, + "target": "es2017", + "traceResolution": false, + "rootDir": "", + "outDir": "../../build/lib", + "typeRoots": [] + }, + "include": [ + "**/*.ts" + ], + "exclude": [] +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.d.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.d.ts new file mode 100644 index 00000000000..1d44190aeed --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.d.ts @@ -0,0 +1,22 @@ +export interface ProcessCov { + result: ScriptCov[]; +} +export interface ScriptCov { + scriptId: string; + url: string; + functions: FunctionCov[]; +} +export interface FunctionCov { + functionName: string; + ranges: RangeCov[]; + isBlockCoverage: boolean; +} +export interface Range { + readonly start: number; + readonly end: number; +} +export interface RangeCov { + startOffset: number; + endOffset: number; + count: number; +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.js b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.js new file mode 100644 index 00000000000..9f4533d133c --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.js @@ -0,0 +1,4 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJ0eXBlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUHJvY2Vzc0NvdiB7XG4gIHJlc3VsdDogU2NyaXB0Q292W107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2NyaXB0Q292IHtcbiAgc2NyaXB0SWQ6IHN0cmluZztcbiAgdXJsOiBzdHJpbmc7XG4gIGZ1bmN0aW9uczogRnVuY3Rpb25Db3ZbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGdW5jdGlvbkNvdiB7XG4gIGZ1bmN0aW9uTmFtZTogc3RyaW5nO1xuICByYW5nZXM6IFJhbmdlQ292W107XG4gIGlzQmxvY2tDb3ZlcmFnZTogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSYW5nZSB7XG4gIHJlYWRvbmx5IHN0YXJ0OiBudW1iZXI7XG4gIHJlYWRvbmx5IGVuZDogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFJhbmdlQ292IHtcbiAgc3RhcnRPZmZzZXQ6IG51bWJlcjtcbiAgZW5kT2Zmc2V0OiBudW1iZXI7XG4gIGNvdW50OiBudW1iZXI7XG59XG4iXSwic291cmNlUm9vdCI6IiJ9 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.mjs b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.mjs new file mode 100644 index 00000000000..d5b9746a122 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/dist/lib/types.mjs @@ -0,0 +1,3 @@ + + +//# sourceMappingURL=data:application/json;charset=utf8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIl9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsImZpbGUiOiJ0eXBlcy5qcyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgUHJvY2Vzc0NvdiB7XG4gIHJlc3VsdDogU2NyaXB0Q292W107XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2NyaXB0Q292IHtcbiAgc2NyaXB0SWQ6IHN0cmluZztcbiAgdXJsOiBzdHJpbmc7XG4gIGZ1bmN0aW9uczogRnVuY3Rpb25Db3ZbXTtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBGdW5jdGlvbkNvdiB7XG4gIGZ1bmN0aW9uTmFtZTogc3RyaW5nO1xuICByYW5nZXM6IFJhbmdlQ292W107XG4gIGlzQmxvY2tDb3ZlcmFnZTogYm9vbGVhbjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBSYW5nZSB7XG4gIHJlYWRvbmx5IHN0YXJ0OiBudW1iZXI7XG4gIHJlYWRvbmx5IGVuZDogbnVtYmVyO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFJhbmdlQ292IHtcbiAgc3RhcnRPZmZzZXQ6IG51bWJlcjtcbiAgZW5kT2Zmc2V0OiBudW1iZXI7XG4gIGNvdW50OiBudW1iZXI7XG59XG4iXSwic291cmNlUm9vdCI6IiJ9 diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/ascii.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/ascii.ts new file mode 100644 index 00000000000..5a52b911416 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/ascii.ts @@ -0,0 +1,146 @@ +import { compareRangeCovs } from "./compare"; +import { RangeCov } from "./types"; + +interface ReadonlyRangeTree { + readonly start: number; + readonly end: number; + readonly count: number; + readonly children: ReadonlyRangeTree[]; +} + +export function emitForest(trees: ReadonlyArray): string { + return emitForestLines(trees).join("\n"); +} + +export function emitForestLines(trees: ReadonlyArray): string[] { + const colMap: Map = getColMap(trees); + const header: string = emitOffsets(colMap); + return [header, ...trees.map(tree => emitTree(tree, colMap).join("\n"))]; +} + +function getColMap(trees: Iterable): Map { + const eventSet: Set = new Set(); + for (const tree of trees) { + const stack: ReadonlyRangeTree[] = [tree]; + while (stack.length > 0) { + const cur: ReadonlyRangeTree = stack.pop()!; + eventSet.add(cur.start); + eventSet.add(cur.end); + for (const child of cur.children) { + stack.push(child); + } + } + } + const events: number[] = [...eventSet]; + events.sort((a, b) => a - b); + let maxDigits: number = 1; + for (const event of events) { + maxDigits = Math.max(maxDigits, event.toString(10).length); + } + const colWidth: number = maxDigits + 3; + const colMap: Map = new Map(); + for (const [i, event] of events.entries()) { + colMap.set(event, i * colWidth); + } + return colMap; +} + +function emitTree(tree: ReadonlyRangeTree, colMap: Map): string[] { + const layers: ReadonlyRangeTree[][] = []; + let nextLayer: ReadonlyRangeTree[] = [tree]; + while (nextLayer.length > 0) { + const layer: ReadonlyRangeTree[] = nextLayer; + layers.push(layer); + nextLayer = []; + for (const node of layer) { + for (const child of node.children) { + nextLayer.push(child); + } + } + } + return layers.map(layer => emitTreeLayer(layer, colMap)); +} + +export function parseFunctionRanges(text: string, offsetMap: Map): RangeCov[] { + const result: RangeCov[] = []; + for (const line of text.split("\n")) { + for (const range of parseTreeLayer(line, offsetMap)) { + result.push(range); + } + } + result.sort(compareRangeCovs); + return result; +} + +/** + * + * @param layer Sorted list of disjoint trees. + * @param colMap + */ +function emitTreeLayer(layer: ReadonlyRangeTree[], colMap: Map): string { + const line: string[] = []; + let curIdx: number = 0; + for (const {start, end, count} of layer) { + const startIdx: number = colMap.get(start)!; + const endIdx: number = colMap.get(end)!; + if (startIdx > curIdx) { + line.push(" ".repeat(startIdx - curIdx)); + } + line.push(emitRange(count, endIdx - startIdx)); + curIdx = endIdx; + } + return line.join(""); +} + +function parseTreeLayer(text: string, offsetMap: Map): RangeCov[] { + const result: RangeCov[] = []; + const regex: RegExp = /\[(\d+)-*\)/gs; + while (true) { + const match: RegExpMatchArray | null = regex.exec(text); + if (match === null) { + break; + } + const startIdx: number = match.index!; + const endIdx: number = startIdx + match[0].length; + const count: number = parseInt(match[1], 10); + const startOffset: number | undefined = offsetMap.get(startIdx); + const endOffset: number | undefined = offsetMap.get(endIdx); + if (startOffset === undefined || endOffset === undefined) { + throw new Error(`Invalid offsets for: ${JSON.stringify(text)}`); + } + result.push({startOffset, endOffset, count}); + } + return result; +} + +function emitRange(count: number, len: number): string { + const rangeStart: string = `[${count.toString(10)}`; + const rangeEnd: string = ")"; + const hyphensLen: number = len - (rangeStart.length + rangeEnd.length); + const hyphens: string = "-".repeat(Math.max(0, hyphensLen)); + return `${rangeStart}${hyphens}${rangeEnd}`; +} + +function emitOffsets(colMap: Map): string { + let line: string = ""; + for (const [event, col] of colMap) { + if (line.length < col) { + line += " ".repeat(col - line.length); + } + line += event.toString(10); + } + return line; +} + +export function parseOffsets(text: string): Map { + const result: Map = new Map(); + const regex: RegExp = /\d+/gs; + while (true) { + const match: RegExpExecArray | null = regex.exec(text); + if (match === null) { + break; + } + result.set(match.index, parseInt(match[0], 10)); + } + return result; +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/clone.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/clone.ts new file mode 100644 index 00000000000..1a910193bc7 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/clone.ts @@ -0,0 +1,70 @@ +import { FunctionCov, ProcessCov, RangeCov, ScriptCov } from "./types"; + +/** + * Creates a deep copy of a process coverage. + * + * @param processCov Process coverage to clone. + * @return Cloned process coverage. + */ +export function cloneProcessCov(processCov: Readonly): ProcessCov { + const result: ScriptCov[] = []; + for (const scriptCov of processCov.result) { + result.push(cloneScriptCov(scriptCov)); + } + + return { + result, + }; +} + +/** + * Creates a deep copy of a script coverage. + * + * @param scriptCov Script coverage to clone. + * @return Cloned script coverage. + */ +export function cloneScriptCov(scriptCov: Readonly): ScriptCov { + const functions: FunctionCov[] = []; + for (const functionCov of scriptCov.functions) { + functions.push(cloneFunctionCov(functionCov)); + } + + return { + scriptId: scriptCov.scriptId, + url: scriptCov.url, + functions, + }; +} + +/** + * Creates a deep copy of a function coverage. + * + * @param functionCov Function coverage to clone. + * @return Cloned function coverage. + */ +export function cloneFunctionCov(functionCov: Readonly): FunctionCov { + const ranges: RangeCov[] = []; + for (const rangeCov of functionCov.ranges) { + ranges.push(cloneRangeCov(rangeCov)); + } + + return { + functionName: functionCov.functionName, + ranges, + isBlockCoverage: functionCov.isBlockCoverage, + }; +} + +/** + * Creates a deep copy of a function coverage. + * + * @param rangeCov Range coverage to clone. + * @return Cloned range coverage. + */ +export function cloneRangeCov(rangeCov: Readonly): RangeCov { + return { + startOffset: rangeCov.startOffset, + endOffset: rangeCov.endOffset, + count: rangeCov.count, + }; +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/compare.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/compare.ts new file mode 100644 index 00000000000..8f5614c244c --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/compare.ts @@ -0,0 +1,40 @@ +import { FunctionCov, RangeCov, ScriptCov } from "./types"; + +/** + * Compares two script coverages. + * + * The result corresponds to the comparison of their `url` value (alphabetical sort). + */ +export function compareScriptCovs(a: Readonly, b: Readonly): number { + if (a.url === b.url) { + return 0; + } else if (a.url < b.url) { + return -1; + } else { + return 1; + } +} + +/** + * Compares two function coverages. + * + * The result corresponds to the comparison of the root ranges. + */ +export function compareFunctionCovs(a: Readonly, b: Readonly): number { + return compareRangeCovs(a.ranges[0], b.ranges[0]); +} + +/** + * Compares two range coverages. + * + * The ranges are first ordered by ascending `startOffset` and then by + * descending `endOffset`. + * This corresponds to a pre-order tree traversal. + */ +export function compareRangeCovs(a: Readonly, b: Readonly): number { + if (a.startOffset !== b.startOffset) { + return a.startOffset - b.startOffset; + } else { + return b.endOffset - a.endOffset; + } +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/index.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/index.ts new file mode 100644 index 00000000000..f92bdf3d4fe --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/index.ts @@ -0,0 +1,6 @@ +export { emitForest, emitForestLines, parseFunctionRanges, parseOffsets } from "./ascii"; +export { cloneFunctionCov, cloneProcessCov, cloneScriptCov, cloneRangeCov } from "./clone"; +export { compareScriptCovs, compareFunctionCovs, compareRangeCovs } from "./compare"; +export { mergeFunctionCovs, mergeProcessCovs, mergeScriptCovs } from "./merge"; +export { RangeTree } from "./range-tree"; +export { ProcessCov, ScriptCov, FunctionCov, RangeCov } from "./types"; diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/merge.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/merge.ts new file mode 100644 index 00000000000..64d191844c0 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/merge.ts @@ -0,0 +1,343 @@ +import { + deepNormalizeScriptCov, + normalizeFunctionCov, + normalizeProcessCov, + normalizeRangeTree, + normalizeScriptCov, +} from "./normalize"; +import { RangeTree } from "./range-tree"; +import { FunctionCov, ProcessCov, Range, RangeCov, ScriptCov } from "./types"; + +/** + * Merges a list of process coverages. + * + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param processCovs Process coverages to merge. + * @return Merged process coverage. + */ +export function mergeProcessCovs(processCovs: ReadonlyArray): ProcessCov { + if (processCovs.length === 0) { + return {result: []}; + } + + const urlToScripts: Map = new Map(); + for (const processCov of processCovs) { + for (const scriptCov of processCov.result) { + let scriptCovs: ScriptCov[] | undefined = urlToScripts.get(scriptCov.url); + if (scriptCovs === undefined) { + scriptCovs = []; + urlToScripts.set(scriptCov.url, scriptCovs); + } + scriptCovs.push(scriptCov); + } + } + + const result: ScriptCov[] = []; + for (const scripts of urlToScripts.values()) { + // assert: `scripts.length > 0` + result.push(mergeScriptCovs(scripts)!); + } + const merged: ProcessCov = {result}; + + normalizeProcessCov(merged); + return merged; +} + +/** + * Merges a list of matching script coverages. + * + * Scripts are matching if they have the same `url`. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param scriptCovs Process coverages to merge. + * @return Merged script coverage, or `undefined` if the input list was empty. + */ +export function mergeScriptCovs(scriptCovs: ReadonlyArray): ScriptCov | undefined { + if (scriptCovs.length === 0) { + return undefined; + } else if (scriptCovs.length === 1) { + const merged: ScriptCov = scriptCovs[0]; + deepNormalizeScriptCov(merged); + return merged; + } + + const first: ScriptCov = scriptCovs[0]; + const scriptId: string = first.scriptId; + const url: string = first.url; + + const rangeToFuncs: Map = new Map(); + for (const scriptCov of scriptCovs) { + for (const funcCov of scriptCov.functions) { + const rootRange: string = stringifyFunctionRootRange(funcCov); + let funcCovs: FunctionCov[] | undefined = rangeToFuncs.get(rootRange); + + if (funcCovs === undefined || + // if the entry in rangeToFuncs is function-level granularity and + // the new coverage is block-level, prefer block-level. + (!funcCovs[0].isBlockCoverage && funcCov.isBlockCoverage)) { + funcCovs = []; + rangeToFuncs.set(rootRange, funcCovs); + } else if (funcCovs[0].isBlockCoverage && !funcCov.isBlockCoverage) { + // if the entry in rangeToFuncs is block-level granularity, we should + // not append function level granularity. + continue; + } + funcCovs.push(funcCov); + } + } + + const functions: FunctionCov[] = []; + for (const funcCovs of rangeToFuncs.values()) { + // assert: `funcCovs.length > 0` + functions.push(mergeFunctionCovs(funcCovs)!); + } + + const merged: ScriptCov = {scriptId, url, functions}; + normalizeScriptCov(merged); + return merged; +} + +/** + * Returns a string representation of the root range of the function. + * + * This string can be used to match function with same root range. + * The string is derived from the start and end offsets of the root range of + * the function. + * This assumes that `ranges` is non-empty (true for valid function coverages). + * + * @param funcCov Function coverage with the range to stringify + * @internal + */ +function stringifyFunctionRootRange(funcCov: Readonly): string { + const rootRange: RangeCov = funcCov.ranges[0]; + return `${rootRange.startOffset.toString(10)};${rootRange.endOffset.toString(10)}`; +} + +/** + * Merges a list of matching function coverages. + * + * Functions are matching if their root ranges have the same span. + * The result is normalized. + * The input values may be mutated, it is not safe to use them after passing + * them to this function. + * The computation is synchronous. + * + * @param funcCovs Function coverages to merge. + * @return Merged function coverage, or `undefined` if the input list was empty. + */ +export function mergeFunctionCovs(funcCovs: ReadonlyArray): FunctionCov | undefined { + if (funcCovs.length === 0) { + return undefined; + } else if (funcCovs.length === 1) { + const merged: FunctionCov = funcCovs[0]; + normalizeFunctionCov(merged); + return merged; + } + + const functionName: string = funcCovs[0].functionName; + + const trees: RangeTree[] = []; + for (const funcCov of funcCovs) { + // assert: `fn.ranges.length > 0` + // assert: `fn.ranges` is sorted + trees.push(RangeTree.fromSortedRanges(funcCov.ranges)!); + } + + // assert: `trees.length > 0` + const mergedTree: RangeTree = mergeRangeTrees(trees)!; + normalizeRangeTree(mergedTree); + const ranges: RangeCov[] = mergedTree.toRanges(); + const isBlockCoverage: boolean = !(ranges.length === 1 && ranges[0].count === 0); + + const merged: FunctionCov = {functionName, ranges, isBlockCoverage}; + // assert: `merged` is normalized + return merged; +} + +/** + * @precondition Same `start` and `end` for all the trees + */ +function mergeRangeTrees(trees: ReadonlyArray): RangeTree | undefined { + if (trees.length <= 1) { + return trees[0]; + } + const first: RangeTree = trees[0]; + let delta: number = 0; + for (const tree of trees) { + delta += tree.delta; + } + const children: RangeTree[] = mergeRangeTreeChildren(trees); + return new RangeTree(first.start, first.end, delta, children); +} + +class RangeTreeWithParent { + readonly parentIndex: number; + readonly tree: RangeTree; + + constructor(parentIndex: number, tree: RangeTree) { + this.parentIndex = parentIndex; + this.tree = tree; + } +} + +class StartEvent { + readonly offset: number; + readonly trees: RangeTreeWithParent[]; + + constructor(offset: number, trees: RangeTreeWithParent[]) { + this.offset = offset; + this.trees = trees; + } + + static compare(a: StartEvent, b: StartEvent): number { + return a.offset - b.offset; + } +} + +class StartEventQueue { + private readonly queue: StartEvent[]; + private nextIndex: number; + private pendingOffset: number; + private pendingTrees: RangeTreeWithParent[] | undefined; + + private constructor(queue: StartEvent[]) { + this.queue = queue; + this.nextIndex = 0; + this.pendingOffset = 0; + this.pendingTrees = undefined; + } + + static fromParentTrees(parentTrees: ReadonlyArray): StartEventQueue { + const startToTrees: Map = new Map(); + for (const [parentIndex, parentTree] of parentTrees.entries()) { + for (const child of parentTree.children) { + let trees: RangeTreeWithParent[] | undefined = startToTrees.get(child.start); + if (trees === undefined) { + trees = []; + startToTrees.set(child.start, trees); + } + trees.push(new RangeTreeWithParent(parentIndex, child)); + } + } + const queue: StartEvent[] = []; + for (const [startOffset, trees] of startToTrees) { + queue.push(new StartEvent(startOffset, trees)); + } + queue.sort(StartEvent.compare); + return new StartEventQueue(queue); + } + + setPendingOffset(offset: number): void { + this.pendingOffset = offset; + } + + pushPendingTree(tree: RangeTreeWithParent): void { + if (this.pendingTrees === undefined) { + this.pendingTrees = []; + } + this.pendingTrees.push(tree); + } + + next(): StartEvent | undefined { + const pendingTrees: RangeTreeWithParent[] | undefined = this.pendingTrees; + const nextEvent: StartEvent | undefined = this.queue[this.nextIndex]; + if (pendingTrees === undefined) { + this.nextIndex++; + return nextEvent; + } else if (nextEvent === undefined) { + this.pendingTrees = undefined; + return new StartEvent(this.pendingOffset, pendingTrees); + } else { + if (this.pendingOffset < nextEvent.offset) { + this.pendingTrees = undefined; + return new StartEvent(this.pendingOffset, pendingTrees); + } else { + if (this.pendingOffset === nextEvent.offset) { + this.pendingTrees = undefined; + for (const tree of pendingTrees) { + nextEvent.trees.push(tree); + } + } + this.nextIndex++; + return nextEvent; + } + } + } +} + +function mergeRangeTreeChildren(parentTrees: ReadonlyArray): RangeTree[] { + const result: RangeTree[] = []; + const startEventQueue: StartEventQueue = StartEventQueue.fromParentTrees(parentTrees); + const parentToNested: Map = new Map(); + let openRange: Range | undefined; + + while (true) { + const event: StartEvent | undefined = startEventQueue.next(); + if (event === undefined) { + break; + } + + if (openRange !== undefined && openRange.end <= event.offset) { + result.push(nextChild(openRange, parentToNested)); + openRange = undefined; + } + + if (openRange === undefined) { + let openRangeEnd: number = event.offset + 1; + for (const {parentIndex, tree} of event.trees) { + openRangeEnd = Math.max(openRangeEnd, tree.end); + insertChild(parentToNested, parentIndex, tree); + } + startEventQueue.setPendingOffset(openRangeEnd); + openRange = {start: event.offset, end: openRangeEnd}; + } else { + for (const {parentIndex, tree} of event.trees) { + if (tree.end > openRange.end) { + const right: RangeTree = tree.split(openRange.end); + startEventQueue.pushPendingTree(new RangeTreeWithParent(parentIndex, right)); + } + insertChild(parentToNested, parentIndex, tree); + } + } + } + if (openRange !== undefined) { + result.push(nextChild(openRange, parentToNested)); + } + + return result; +} + +function insertChild(parentToNested: Map, parentIndex: number, tree: RangeTree): void { + let nested: RangeTree[] | undefined = parentToNested.get(parentIndex); + if (nested === undefined) { + nested = []; + parentToNested.set(parentIndex, nested); + } + nested.push(tree); +} + +function nextChild(openRange: Range, parentToNested: Map): RangeTree { + const matchingTrees: RangeTree[] = []; + + for (const nested of parentToNested.values()) { + if (nested.length === 1 && nested[0].start === openRange.start && nested[0].end === openRange.end) { + matchingTrees.push(nested[0]); + } else { + matchingTrees.push(new RangeTree( + openRange.start, + openRange.end, + 0, + nested, + )); + } + } + parentToNested.clear(); + return mergeRangeTrees(matchingTrees)!; +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/normalize.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/normalize.ts new file mode 100644 index 00000000000..02691161497 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/normalize.ts @@ -0,0 +1,84 @@ +import { compareFunctionCovs, compareRangeCovs, compareScriptCovs } from "./compare"; +import { RangeTree } from "./range-tree"; +import { FunctionCov, ProcessCov, ScriptCov } from "./types"; + +/** + * Normalizes a process coverage. + * + * Sorts the scripts alphabetically by `url`. + * Reassigns script ids: the script at index `0` receives `"0"`, the script at + * index `1` receives `"1"` etc. + * This does not normalize the script coverages. + * + * @param processCov Process coverage to normalize. + */ +export function normalizeProcessCov(processCov: ProcessCov): void { + processCov.result.sort(compareScriptCovs); + for (const [scriptId, scriptCov] of processCov.result.entries()) { + scriptCov.scriptId = scriptId.toString(10); + } +} + +/** + * Normalizes a process coverage deeply. + * + * Normalizes the script coverages deeply, then normalizes the process coverage + * itself. + * + * @param processCov Process coverage to normalize. + */ +export function deepNormalizeProcessCov(processCov: ProcessCov): void { + for (const scriptCov of processCov.result) { + deepNormalizeScriptCov(scriptCov); + } + normalizeProcessCov(processCov); +} + +/** + * Normalizes a script coverage. + * + * Sorts the function by root range (pre-order sort). + * This does not normalize the function coverages. + * + * @param scriptCov Script coverage to normalize. + */ +export function normalizeScriptCov(scriptCov: ScriptCov): void { + scriptCov.functions.sort(compareFunctionCovs); +} + +/** + * Normalizes a script coverage deeply. + * + * Normalizes the function coverages deeply, then normalizes the script coverage + * itself. + * + * @param scriptCov Script coverage to normalize. + */ +export function deepNormalizeScriptCov(scriptCov: ScriptCov): void { + for (const funcCov of scriptCov.functions) { + normalizeFunctionCov(funcCov); + } + normalizeScriptCov(scriptCov); +} + +/** + * Normalizes a function coverage. + * + * Sorts the ranges (pre-order sort). + * TODO: Tree-based normalization of the ranges. + * + * @param funcCov Function coverage to normalize. + */ +export function normalizeFunctionCov(funcCov: FunctionCov): void { + funcCov.ranges.sort(compareRangeCovs); + const tree: RangeTree = RangeTree.fromSortedRanges(funcCov.ranges)!; + normalizeRangeTree(tree); + funcCov.ranges = tree.toRanges(); +} + +/** + * @internal + */ +export function normalizeRangeTree(tree: RangeTree): void { + tree.normalize(); +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/range-tree.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/range-tree.ts new file mode 100644 index 00000000000..941ec82eda4 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/range-tree.ts @@ -0,0 +1,156 @@ +import { RangeCov } from "./types"; + +export class RangeTree { + start: number; + end: number; + delta: number; + children: RangeTree[]; + + constructor( + start: number, + end: number, + delta: number, + children: RangeTree[], + ) { + this.start = start; + this.end = end; + this.delta = delta; + this.children = children; + } + + /** + * @precodition `ranges` are well-formed and pre-order sorted + */ + static fromSortedRanges(ranges: ReadonlyArray): RangeTree | undefined { + let root: RangeTree | undefined; + // Stack of parent trees and parent counts. + const stack: [RangeTree, number][] = []; + for (const range of ranges) { + const node: RangeTree = new RangeTree(range.startOffset, range.endOffset, range.count, []); + if (root === undefined) { + root = node; + stack.push([node, range.count]); + continue; + } + let parent: RangeTree; + let parentCount: number; + while (true) { + [parent, parentCount] = stack[stack.length - 1]; + // assert: `top !== undefined` (the ranges are sorted) + if (range.startOffset < parent.end) { + break; + } else { + stack.pop(); + } + } + node.delta -= parentCount; + parent.children.push(node); + stack.push([node, range.count]); + } + return root; + } + + normalize(): void { + const children: RangeTree[] = []; + let curEnd: number; + let head: RangeTree | undefined; + const tail: RangeTree[] = []; + for (const child of this.children) { + if (head === undefined) { + head = child; + } else if (child.delta === head.delta && child.start === curEnd!) { + tail.push(child); + } else { + endChain(); + head = child; + } + curEnd = child.end; + } + if (head !== undefined) { + endChain(); + } + + if (children.length === 1) { + const child: RangeTree = children[0]; + if (child.start === this.start && child.end === this.end) { + this.delta += child.delta; + this.children = child.children; + // `.lazyCount` is zero for both (both are after normalization) + return; + } + } + + this.children = children; + + function endChain(): void { + if (tail.length !== 0) { + head!.end = tail[tail.length - 1].end; + for (const tailTree of tail) { + for (const subChild of tailTree.children) { + subChild.delta += tailTree.delta - head!.delta; + head!.children.push(subChild); + } + } + tail.length = 0; + } + head!.normalize(); + children.push(head!); + } + } + + /** + * @precondition `tree.start < value && value < tree.end` + * @return RangeTree Right part + */ + split(value: number): RangeTree { + let leftChildLen: number = this.children.length; + let mid: RangeTree | undefined; + + // TODO(perf): Binary search (check overhead) + for (let i: number = 0; i < this.children.length; i++) { + const child: RangeTree = this.children[i]; + if (child.start < value && value < child.end) { + mid = child.split(value); + leftChildLen = i + 1; + break; + } else if (child.start >= value) { + leftChildLen = i; + break; + } + } + + const rightLen: number = this.children.length - leftChildLen; + const rightChildren: RangeTree[] = this.children.splice(leftChildLen, rightLen); + if (mid !== undefined) { + rightChildren.unshift(mid); + } + const result: RangeTree = new RangeTree( + value, + this.end, + this.delta, + rightChildren, + ); + this.end = value; + return result; + } + + /** + * Get the range coverages corresponding to the tree. + * + * The ranges are pre-order sorted. + */ + toRanges(): RangeCov[] { + const ranges: RangeCov[] = []; + // Stack of parent trees and counts. + const stack: [RangeTree, number][] = [[this, 0]]; + while (stack.length > 0) { + const [cur, parentCount]: [RangeTree, number] = stack.pop()!; + const count: number = parentCount + cur.delta; + ranges.push({startOffset: cur.start, endOffset: cur.end, count}); + for (let i: number = cur.children.length - 1; i >= 0; i--) { + stack.push([cur.children[i], count]); + } + } + return ranges; + } +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/types.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/types.ts new file mode 100644 index 00000000000..cc2cfc579ed --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/lib/types.ts @@ -0,0 +1,26 @@ +export interface ProcessCov { + result: ScriptCov[]; +} + +export interface ScriptCov { + scriptId: string; + url: string; + functions: FunctionCov[]; +} + +export interface FunctionCov { + functionName: string; + ranges: RangeCov[]; + isBlockCoverage: boolean; +} + +export interface Range { + readonly start: number; + readonly end: number; +} + +export interface RangeCov { + startOffset: number; + endOffset: number; + count: number; +} diff --git a/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/test/merge.spec.ts b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/test/merge.spec.ts new file mode 100644 index 00000000000..9d5522a20bf --- /dev/null +++ b/src/DynamoSandbox/node_modules/@bcoe/v8-coverage/src/test/merge.spec.ts @@ -0,0 +1,280 @@ +import chai from "chai"; +import fs from "fs"; +import path from "path"; +import { FunctionCov, mergeFunctionCovs, mergeProcessCovs, mergeScriptCovs, ProcessCov, ScriptCov } from "../lib"; + +const REPO_ROOT: string = path.join(__dirname, "..", "..", "..", ".."); +const BENCHES_INPUT_DIR: string = path.join(REPO_ROOT, "benches"); +const BENCHES_DIR: string = path.join(REPO_ROOT, "test-data", "merge", "benches"); +const RANGES_DIR: string = path.join(REPO_ROOT, "test-data", "merge", "ranges"); +const BENCHES_TIMEOUT: number = 20000; // 20sec + +interface MergeRangeItem { + name: string; + status: "run" | "skip" | "only"; + inputs: ProcessCov[]; + expected: ProcessCov; +} + +const FIXTURES_DIR: string = path.join(REPO_ROOT, "test-data", "bugs"); +function loadFixture(name: string) { + const content: string = fs.readFileSync( + path.resolve(FIXTURES_DIR, `${name}.json`), + {encoding: "UTF-8"}, + ); + return JSON.parse(content); +} + +describe("merge", () => { + describe("Various", () => { + it("accepts empty arrays for `mergeProcessCovs`", () => { + const inputs: ProcessCov[] = []; + const expected: ProcessCov = {result: []}; + const actual: ProcessCov = mergeProcessCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + + it("accepts empty arrays for `mergeScriptCovs`", () => { + const inputs: ScriptCov[] = []; + const expected: ScriptCov | undefined = undefined; + const actual: ScriptCov | undefined = mergeScriptCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + + it("accepts empty arrays for `mergeFunctionCovs`", () => { + const inputs: FunctionCov[] = []; + const expected: FunctionCov | undefined = undefined; + const actual: FunctionCov | undefined = mergeFunctionCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + + it("accepts arrays with a single item for `mergeProcessCovs`", () => { + const inputs: ProcessCov[] = [ + { + result: [ + { + scriptId: "123", + url: "/lib.js", + functions: [ + { + functionName: "test", + isBlockCoverage: true, + ranges: [ + {startOffset: 0, endOffset: 4, count: 2}, + {startOffset: 1, endOffset: 2, count: 1}, + {startOffset: 2, endOffset: 3, count: 1}, + ], + }, + ], + }, + ], + }, + ]; + const expected: ProcessCov = { + result: [ + { + scriptId: "0", + url: "/lib.js", + functions: [ + { + functionName: "test", + isBlockCoverage: true, + ranges: [ + {startOffset: 0, endOffset: 4, count: 2}, + {startOffset: 1, endOffset: 3, count: 1}, + ], + }, + ], + }, + ], + }; + const actual: ProcessCov = mergeProcessCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + + describe("mergeProcessCovs", () => { + // see: https://github.com/demurgos/v8-coverage/issues/2 + it("handles function coverage merged into block coverage", () => { + const blockCoverage: ProcessCov = loadFixture("issue-2-block-coverage"); + const functionCoverage: ProcessCov = loadFixture("issue-2-func-coverage"); + const inputs: ProcessCov[] = [ + functionCoverage, + blockCoverage, + ]; + const expected: ProcessCov = loadFixture("issue-2-expected"); + const actual: ProcessCov = mergeProcessCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + + // see: https://github.com/demurgos/v8-coverage/issues/2 + it("handles block coverage merged into function coverage", () => { + const blockCoverage: ProcessCov = loadFixture("issue-2-block-coverage"); + const functionCoverage: ProcessCov = loadFixture("issue-2-func-coverage"); + const inputs: ProcessCov[] = [ + blockCoverage, + functionCoverage, + ]; + const expected: ProcessCov = loadFixture("issue-2-expected"); + const actual: ProcessCov = mergeProcessCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + }); + + it("accepts arrays with a single item for `mergeScriptCovs`", () => { + const inputs: ScriptCov[] = [ + { + scriptId: "123", + url: "/lib.js", + functions: [ + { + functionName: "test", + isBlockCoverage: true, + ranges: [ + {startOffset: 0, endOffset: 4, count: 2}, + {startOffset: 1, endOffset: 2, count: 1}, + {startOffset: 2, endOffset: 3, count: 1}, + ], + }, + ], + }, + ]; + const expected: ScriptCov | undefined = { + scriptId: "123", + url: "/lib.js", + functions: [ + { + functionName: "test", + isBlockCoverage: true, + ranges: [ + {startOffset: 0, endOffset: 4, count: 2}, + {startOffset: 1, endOffset: 3, count: 1}, + ], + }, + ], + }; + const actual: ScriptCov | undefined = mergeScriptCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + + it("accepts arrays with a single item for `mergeFunctionCovs`", () => { + const inputs: FunctionCov[] = [ + { + functionName: "test", + isBlockCoverage: true, + ranges: [ + {startOffset: 0, endOffset: 4, count: 2}, + {startOffset: 1, endOffset: 2, count: 1}, + {startOffset: 2, endOffset: 3, count: 1}, + ], + }, + ]; + const expected: FunctionCov = { + functionName: "test", + isBlockCoverage: true, + ranges: [ + {startOffset: 0, endOffset: 4, count: 2}, + {startOffset: 1, endOffset: 3, count: 1}, + ], + }; + const actual: FunctionCov | undefined = mergeFunctionCovs(inputs); + chai.assert.deepEqual(actual, expected); + }); + }); + + describe("ranges", () => { + for (const sourceFile of getSourceFiles()) { + const relPath: string = path.relative(RANGES_DIR, sourceFile); + describe(relPath, () => { + const content: string = fs.readFileSync(sourceFile, {encoding: "UTF-8"}); + const items: MergeRangeItem[] = JSON.parse(content); + for (const item of items) { + const test: () => void = () => { + const actual: ProcessCov | undefined = mergeProcessCovs(item.inputs); + chai.assert.deepEqual(actual, item.expected); + }; + switch (item.status) { + case "run": + it(item.name, test); + break; + case "only": + it.only(item.name, test); + break; + case "skip": + it.skip(item.name, test); + break; + default: + throw new Error(`Unexpected status: ${item.status}`); + } + } + }); + } + }); + + describe("benches", () => { + for (const bench of getBenches()) { + const BENCHES_TO_SKIP: Set = new Set(); + if (process.env.CI === "true") { + // Skip very large benchmarks when running continuous integration + BENCHES_TO_SKIP.add("node@10.11.0"); + BENCHES_TO_SKIP.add("npm@6.4.1"); + } + + const name: string = path.basename(bench); + + if (BENCHES_TO_SKIP.has(name)) { + it.skip(`${name} (skipped: too large for CI)`, testBench); + } else { + it(name, testBench); + } + + async function testBench(this: Mocha.Context) { + this.timeout(BENCHES_TIMEOUT); + + const inputFileNames: string[] = await fs.promises.readdir(bench); + const inputPromises: Promise[] = []; + for (const inputFileName of inputFileNames) { + const resolved: string = path.join(bench, inputFileName); + inputPromises.push(fs.promises.readFile(resolved).then(buffer => JSON.parse(buffer.toString("UTF-8")))); + } + const inputs: ProcessCov[] = await Promise.all(inputPromises); + const expectedPath: string = path.join(BENCHES_DIR, `${name}.json`); + const expectedContent: string = await fs.promises.readFile(expectedPath, {encoding: "UTF-8"}) as string; + const expected: ProcessCov = JSON.parse(expectedContent); + const startTime: number = Date.now(); + const actual: ProcessCov | undefined = mergeProcessCovs(inputs); + const endTime: number = Date.now(); + console.error(`Time (${name}): ${(endTime - startTime) / 1000}`); + chai.assert.deepEqual(actual, expected); + console.error(`OK: ${name}`); + } + } + }); +}); + +function getSourceFiles() { + return getSourcesFrom(RANGES_DIR); + + function* getSourcesFrom(dir: string): Iterable { + const names: string[] = fs.readdirSync(dir); + for (const name of names) { + const resolved: string = path.join(dir, name); + const stat: fs.Stats = fs.statSync(resolved); + if (stat.isDirectory()) { + yield* getSourcesFrom(dir); + } else { + yield resolved; + } + } + } +} + +function* getBenches(): Iterable { + const names: string[] = fs.readdirSync(BENCHES_INPUT_DIR); + for (const name of names) { + const resolved: string = path.join(BENCHES_INPUT_DIR, name); + const stat: fs.Stats = fs.statSync(resolved); + if (stat.isDirectory()) { + yield resolved; + } + } +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/assets/jest_logo.png b/src/DynamoSandbox/node_modules/@jest/core/build/assets/jest_logo.png new file mode 100644 index 0000000000000000000000000000000000000000..079356bc1611ac3e6016552af1fb4c9339b8165a GIT binary patch literal 3157 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 vcX%i|9Kn(L{|zt_P@vA@JWOa9u?^): Promise<{ + results: AggregatedResult; + globalConfig: Config.GlobalConfig; +}>; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/cli/index.js b/src/DynamoSandbox/node_modules/@jest/core/build/cli/index.js new file mode 100644 index 00000000000..2844390733f --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/cli/index.js @@ -0,0 +1,399 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.runCLI = runCLI; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _exit() { + const data = _interopRequireDefault(require('exit')); + + _exit = function () { + return data; + }; + + return data; +} + +function _rimraf() { + const data = _interopRequireDefault(require('rimraf')); + + _rimraf = function () { + return data; + }; + + return data; +} + +function _console() { + const data = require('@jest/console'); + + _console = function () { + return data; + }; + + return data; +} + +function _jestConfig() { + const data = require('jest-config'); + + _jestConfig = function () { + return data; + }; + + return data; +} + +function _jestRuntime() { + const data = _interopRequireDefault(require('jest-runtime')); + + _jestRuntime = function () { + return data; + }; + + return data; +} + +function _jestUtil() { + const data = require('jest-util'); + + _jestUtil = function () { + return data; + }; + + return data; +} + +var _TestWatcher = _interopRequireDefault(require('../TestWatcher')); + +var _collectHandles = require('../collectHandles'); + +var _getChangedFilesPromise = _interopRequireDefault( + require('../getChangedFilesPromise') +); + +var _getConfigsOfProjectsToRun = _interopRequireDefault( + require('../getConfigsOfProjectsToRun') +); + +var _getProjectNamesMissingWarning = _interopRequireDefault( + require('../getProjectNamesMissingWarning') +); + +var _getSelectProjectsMessage = _interopRequireDefault( + require('../getSelectProjectsMessage') +); + +var _createContext = _interopRequireDefault(require('../lib/createContext')); + +var _handleDeprecationWarnings = _interopRequireDefault( + require('../lib/handleDeprecationWarnings') +); + +var _logDebugMessages = _interopRequireDefault( + require('../lib/logDebugMessages') +); + +var _pluralize = _interopRequireDefault(require('../pluralize')); + +var _runJest = _interopRequireDefault(require('../runJest')); + +var _watch = _interopRequireDefault(require('../watch')); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +const {print: preRunMessagePrint} = _jestUtil().preRunMessage; + +async function runCLI(argv, projects) { + let results; // If we output a JSON object, we can't write anything to stdout, since + // it'll break the JSON structure and it won't be valid. + + const outputStream = + argv.json || argv.useStderr ? process.stderr : process.stdout; + const {globalConfig, configs, hasDeprecationWarnings} = await (0, + _jestConfig().readConfigs)(argv, projects); + + if (argv.debug) { + (0, _logDebugMessages.default)(globalConfig, configs, outputStream); + } + + if (argv.showConfig) { + (0, _logDebugMessages.default)(globalConfig, configs, process.stdout); + (0, _exit().default)(0); + } + + if (argv.clearCache) { + configs.forEach(config => { + _rimraf().default.sync(config.cacheDirectory); + + process.stdout.write(`Cleared ${config.cacheDirectory}\n`); + }); + (0, _exit().default)(0); + } + + let configsOfProjectsToRun = configs; + + if (argv.selectProjects) { + const namesMissingWarning = (0, _getProjectNamesMissingWarning.default)( + configs + ); + + if (namesMissingWarning) { + outputStream.write(namesMissingWarning); + } + + configsOfProjectsToRun = (0, _getConfigsOfProjectsToRun.default)( + argv.selectProjects, + configs + ); + outputStream.write( + (0, _getSelectProjectsMessage.default)(configsOfProjectsToRun) + ); + } + + await _run10000( + globalConfig, + configsOfProjectsToRun, + hasDeprecationWarnings, + outputStream, + r => { + results = r; + } + ); + + if (argv.watch || argv.watchAll) { + // If in watch mode, return the promise that will never resolve. + // If the watch mode is interrupted, watch should handle the process + // shutdown. + return new Promise(() => {}); + } + + if (!results) { + throw new Error( + 'AggregatedResult must be present after test run is complete' + ); + } + + const {openHandles} = results; + + if (openHandles && openHandles.length) { + const formatted = (0, _collectHandles.formatHandleErrors)( + openHandles, + configs[0] + ); + const openHandlesString = (0, _pluralize.default)( + 'open handle', + formatted.length, + 's' + ); + const message = + _chalk().default.red( + `\nJest has detected the following ${openHandlesString} potentially keeping Jest from exiting:\n\n` + ) + formatted.join('\n\n'); + console.error(message); + } + + return { + globalConfig, + results + }; +} + +const buildContextsAndHasteMaps = async ( + configs, + globalConfig, + outputStream +) => { + const hasteMapInstances = Array(configs.length); + const contexts = await Promise.all( + configs.map(async (config, index) => { + (0, _jestUtil().createDirectory)(config.cacheDirectory); + + const hasteMapInstance = _jestRuntime().default.createHasteMap(config, { + console: new (_console().CustomConsole)(outputStream, outputStream), + maxWorkers: Math.max( + 1, + Math.floor(globalConfig.maxWorkers / configs.length) + ), + resetCache: !config.cache, + watch: globalConfig.watch || globalConfig.watchAll, + watchman: globalConfig.watchman + }); + + hasteMapInstances[index] = hasteMapInstance; + return (0, _createContext.default)( + config, + await hasteMapInstance.build() + ); + }) + ); + return { + contexts, + hasteMapInstances + }; +}; + +const _run10000 = async ( + globalConfig, + configs, + hasDeprecationWarnings, + outputStream, + onComplete +) => { + // Queries to hg/git can take a while, so we need to start the process + // as soon as possible, so by the time we need the result it's already there. + const changedFilesPromise = (0, _getChangedFilesPromise.default)( + globalConfig, + configs + ); // Filter may need to do an HTTP call or something similar to setup. + // We will wait on an async response from this before using the filter. + + let filter; + + if (globalConfig.filter && !globalConfig.skipFilter) { + const rawFilter = require(globalConfig.filter); + + let filterSetupPromise; + + if (rawFilter.setup) { + // Wrap filter setup Promise to avoid "uncaught Promise" error. + // If an error is returned, we surface it in the return value. + filterSetupPromise = (async () => { + try { + await rawFilter.setup(); + } catch (err) { + return err; + } + + return undefined; + })(); + } + + filter = async testPaths => { + if (filterSetupPromise) { + // Expect an undefined return value unless there was an error. + const err = await filterSetupPromise; + + if (err) { + throw err; + } + } + + return rawFilter(testPaths); + }; + } + + const {contexts, hasteMapInstances} = await buildContextsAndHasteMaps( + configs, + globalConfig, + outputStream + ); + globalConfig.watch || globalConfig.watchAll + ? await runWatch( + contexts, + configs, + hasDeprecationWarnings, + globalConfig, + outputStream, + hasteMapInstances, + filter + ) + : await runWithoutWatch( + globalConfig, + contexts, + outputStream, + onComplete, + changedFilesPromise, + filter + ); +}; + +const runWatch = async ( + contexts, + _configs, + hasDeprecationWarnings, + globalConfig, + outputStream, + hasteMapInstances, + filter +) => { + if (hasDeprecationWarnings) { + try { + await (0, _handleDeprecationWarnings.default)( + outputStream, + process.stdin + ); + return (0, _watch.default)( + globalConfig, + contexts, + outputStream, + hasteMapInstances, + undefined, + undefined, + filter + ); + } catch { + (0, _exit().default)(0); + } + } + + return (0, _watch.default)( + globalConfig, + contexts, + outputStream, + hasteMapInstances, + undefined, + undefined, + filter + ); +}; + +const runWithoutWatch = async ( + globalConfig, + contexts, + outputStream, + onComplete, + changedFilesPromise, + filter +) => { + const startRun = async () => { + if (!globalConfig.listTests) { + preRunMessagePrint(outputStream); + } + + return (0, _runJest.default)({ + changedFilesPromise, + contexts, + failedTestsCache: undefined, + filter, + globalConfig, + onComplete, + outputStream, + startRun, + testWatcher: new _TestWatcher.default({ + isWatchMode: false + }) + }); + }; + + return startRun(); +}; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts new file mode 100644 index 00000000000..15f595ae0f1 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { Config } from '@jest/types'; +declare const activeFilters: (globalConfig: Config.GlobalConfig, delimiter?: string) => string; +export default activeFilters; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.js b/src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.js new file mode 100644 index 00000000000..ff633327584 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/activeFiltersMessage.js @@ -0,0 +1,54 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +const activeFilters = (globalConfig, delimiter = '\n') => { + const {testNamePattern, testPathPattern} = globalConfig; + + if (testNamePattern || testPathPattern) { + const filters = [ + testPathPattern + ? _chalk().default.dim('filename ') + + _chalk().default.yellow('/' + testPathPattern + '/') + : null, + testNamePattern + ? _chalk().default.dim('test name ') + + _chalk().default.yellow('/' + testNamePattern + '/') + : null + ] + .filter(f => f) + .join(', '); + const messages = [ + '\n' + _chalk().default.bold('Active Filters: ') + filters + ]; + return messages.filter(message => !!message).join(delimiter); + } + + return ''; +}; + +var _default = activeFilters; +exports.default = _default; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.d.ts new file mode 100644 index 00000000000..c98a3ef029c --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.d.ts @@ -0,0 +1,10 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { Config } from '@jest/types'; +import type { HasteMapObject } from 'jest-haste-map'; +import { Context } from 'jest-runtime'; +export default function createContext(config: Config.ProjectConfig, { hasteFS, moduleMap }: HasteMapObject): Context; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.js b/src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.js new file mode 100644 index 00000000000..b360e9c5c82 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/createContext.js @@ -0,0 +1,35 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = createContext; + +function _jestRuntime() { + const data = _interopRequireDefault(require('jest-runtime')); + + _jestRuntime = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +function createContext(config, {hasteFS, moduleMap}) { + return { + config, + hasteFS, + moduleMap, + resolver: _jestRuntime().default.createResolver(config, moduleMap) + }; +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts new file mode 100644 index 00000000000..8d2151e98aa --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// +export default function handleDeprecationWarnings(pipe: NodeJS.WriteStream, stdin?: NodeJS.ReadStream): Promise; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js b/src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js new file mode 100644 index 00000000000..f0a15d6111a --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/handleDeprecationWarnings.js @@ -0,0 +1,72 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = handleDeprecationWarnings; + +function _chalk() { + const data = _interopRequireDefault(require('chalk')); + + _chalk = function () { + return data; + }; + + return data; +} + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +function handleDeprecationWarnings(pipe, stdin = process.stdin) { + return new Promise((resolve, reject) => { + if (typeof stdin.setRawMode === 'function') { + const messages = [ + _chalk().default.red('There are deprecation warnings.\n'), + _chalk().default.dim(' \u203A Press ') + + 'Enter' + + _chalk().default.dim(' to continue.'), + _chalk().default.dim(' \u203A Press ') + + 'Esc' + + _chalk().default.dim(' to exit.') + ]; + pipe.write(messages.join('\n')); + stdin.setRawMode(true); + stdin.resume(); + stdin.setEncoding('utf8'); // this is a string since we set encoding above + + stdin.on('data', key => { + if (key === _jestWatcher().KEYS.ENTER) { + resolve(); + } else if ( + [ + _jestWatcher().KEYS.ESCAPE, + _jestWatcher().KEYS.CONTROL_C, + _jestWatcher().KEYS.CONTROL_D + ].indexOf(key) !== -1 + ) { + reject(); + } + }); + } else { + resolve(); + } + }); +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.d.ts new file mode 100644 index 00000000000..d81880adc17 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.d.ts @@ -0,0 +1,8 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { Config } from '@jest/types'; +export default function isValidPath(globalConfig: Config.GlobalConfig, filePath: Config.Path): boolean; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.js b/src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.js new file mode 100644 index 00000000000..10971d38b78 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/isValidPath.js @@ -0,0 +1,29 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = isValidPath; + +function _jestSnapshot() { + const data = require('jest-snapshot'); + + _jestSnapshot = function () { + return data; + }; + + return data; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +function isValidPath(globalConfig, filePath) { + return ( + !filePath.includes(globalConfig.coverageDirectory) && + !(0, _jestSnapshot().isSnapshotPath)(filePath) + ); +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.d.ts new file mode 100644 index 00000000000..b312cd9e1b5 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.d.ts @@ -0,0 +1,9 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// +import type { Config } from '@jest/types'; +export default function logDebugMessages(globalConfig: Config.GlobalConfig, configs: Array | Config.ProjectConfig, outputStream: NodeJS.WriteStream): void; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.js b/src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.js new file mode 100644 index 00000000000..9c1f2f5fc99 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/logDebugMessages.js @@ -0,0 +1,23 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = logDebugMessages; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +const VERSION = require('../../package.json').version; // if the output here changes, update `getConfig` in e2e/runJest.ts + +function logDebugMessages(globalConfig, configs, outputStream) { + const output = { + configs, + globalConfig, + version: VERSION + }; + outputStream.write(JSON.stringify(output, null, ' ') + '\n'); +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts new file mode 100644 index 00000000000..8282936e928 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.d.ts @@ -0,0 +1,11 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { Config } from '@jest/types'; +import type { AllowedConfigOptions } from 'jest-watcher'; +declare type ExtraConfigOptions = Partial>; +export default function updateGlobalConfig(globalConfig: Config.GlobalConfig, options?: AllowedConfigOptions & ExtraConfigOptions): Config.GlobalConfig; +export {}; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.js b/src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.js new file mode 100644 index 00000000000..5c495863b6b --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/updateGlobalConfig.js @@ -0,0 +1,121 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = updateGlobalConfig; + +function _jestRegexUtil() { + const data = require('jest-regex-util'); + + _jestRegexUtil = function () { + return data; + }; + + return data; +} + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +function updateGlobalConfig(globalConfig, options = {}) { + const newConfig = {...globalConfig}; + + if (options.mode === 'watch') { + newConfig.watch = true; + newConfig.watchAll = false; + } else if (options.mode === 'watchAll') { + newConfig.watch = false; + newConfig.watchAll = true; + } + + if (options.testNamePattern !== undefined) { + newConfig.testNamePattern = options.testNamePattern || ''; + } + + if (options.testPathPattern !== undefined) { + newConfig.testPathPattern = + (0, _jestRegexUtil().replacePathSepForRegex)(options.testPathPattern) || + ''; + } + + newConfig.onlyChanged = + !newConfig.watchAll && + !newConfig.testNamePattern && + !newConfig.testPathPattern; + + if (typeof options.bail === 'boolean') { + newConfig.bail = options.bail ? 1 : 0; + } else if (options.bail !== undefined) { + newConfig.bail = options.bail; + } + + if (options.changedSince !== undefined) { + newConfig.changedSince = options.changedSince; + } + + if (options.collectCoverage !== undefined) { + newConfig.collectCoverage = options.collectCoverage || false; + } + + if (options.collectCoverageFrom !== undefined) { + newConfig.collectCoverageFrom = options.collectCoverageFrom; + } + + if (options.collectCoverageOnlyFrom !== undefined) { + newConfig.collectCoverageOnlyFrom = options.collectCoverageOnlyFrom; + } + + if (options.coverageDirectory !== undefined) { + newConfig.coverageDirectory = options.coverageDirectory; + } + + if (options.coverageReporters !== undefined) { + newConfig.coverageReporters = options.coverageReporters; + } + + if (options.findRelatedTests !== undefined) { + newConfig.findRelatedTests = options.findRelatedTests; + } + + if (options.nonFlagArgs !== undefined) { + newConfig.nonFlagArgs = options.nonFlagArgs; + } + + if (options.noSCM) { + newConfig.noSCM = true; + } + + if (options.notify !== undefined) { + newConfig.notify = options.notify || false; + } + + if (options.notifyMode !== undefined) { + newConfig.notifyMode = options.notifyMode; + } + + if (options.onlyFailures !== undefined) { + newConfig.onlyFailures = options.onlyFailures || false; + } + + if (options.passWithNoTests !== undefined) { + newConfig.passWithNoTests = true; + } + + if (options.reporters !== undefined) { + newConfig.reporters = options.reporters; + } + + if (options.updateSnapshot !== undefined) { + newConfig.updateSnapshot = options.updateSnapshot; + } + + if (options.verbose !== undefined) { + newConfig.verbose = options.verbose || false; + } + + return Object.freeze(newConfig); +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts new file mode 100644 index 00000000000..99e8d7f7288 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.d.ts @@ -0,0 +1,10 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { Config } from '@jest/types'; +import type { UsageData, WatchPlugin } from 'jest-watcher'; +export declare const filterInteractivePlugins: (watchPlugins: Array, globalConfig: Config.GlobalConfig) => Array; +export declare const getSortedUsageRows: (watchPlugins: Array, globalConfig: Config.GlobalConfig) => Array; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.js b/src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.js new file mode 100644 index 00000000000..9f595ce2a21 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/lib/watchPluginsHelpers.js @@ -0,0 +1,62 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.getSortedUsageRows = exports.filterInteractivePlugins = void 0; + +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +const filterInteractivePlugins = (watchPlugins, globalConfig) => { + const usageInfos = watchPlugins.map( + p => p.getUsageInfo && p.getUsageInfo(globalConfig) + ); + return watchPlugins.filter((_plugin, i) => { + const usageInfo = usageInfos[i]; + + if (usageInfo) { + const {key} = usageInfo; + return !usageInfos.slice(i + 1).some(u => !!u && key === u.key); + } + + return false; + }); +}; + +exports.filterInteractivePlugins = filterInteractivePlugins; + +function notEmpty(value) { + return value != null; +} + +const getSortedUsageRows = (watchPlugins, globalConfig) => + filterInteractivePlugins(watchPlugins, globalConfig) + .sort((a, b) => { + if (a.isInternal && b.isInternal) { + // internal plugins in the order we specify them + return 0; + } + + if (a.isInternal !== b.isInternal) { + // external plugins afterwards + return a.isInternal ? -1 : 1; + } + + const usageInfoA = a.getUsageInfo && a.getUsageInfo(globalConfig); + const usageInfoB = b.getUsageInfo && b.getUsageInfo(globalConfig); + + if (usageInfoA && usageInfoB) { + // external plugins in alphabetical order + return usageInfoA.key.localeCompare(usageInfoB.key); + } + + return 0; + }) + .map(p => p.getUsageInfo && p.getUsageInfo(globalConfig)) + .filter(notEmpty); + +exports.getSortedUsageRows = getSortedUsageRows; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts new file mode 100644 index 00000000000..d6961819ecf --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.d.ts @@ -0,0 +1,17 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, JestHookSubscriber, UpdateConfigCallback, UsageData } from 'jest-watcher'; +export default class FailedTestsInteractivePlugin extends BaseWatchPlugin { + private _failedTestAssertions?; + private readonly _manager; + apply(hooks: JestHookSubscriber): void; + getUsageInfo(): UsageData | null; + onKey(key: string): void; + run(_: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise; + private getFailedTestAssertions; +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js new file mode 100644 index 00000000000..a830abed633 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/FailedTestsInteractive.js @@ -0,0 +1,135 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _FailedTestsInteractiveMode = _interopRequireDefault( + require('../FailedTestsInteractiveMode') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +class FailedTestsInteractivePlugin extends _jestWatcher().BaseWatchPlugin { + constructor(...args) { + super(...args); + + _defineProperty(this, '_failedTestAssertions', void 0); + + _defineProperty( + this, + '_manager', + new _FailedTestsInteractiveMode.default(this._stdout) + ); + } + + apply(hooks) { + hooks.onTestRunComplete(results => { + this._failedTestAssertions = this.getFailedTestAssertions(results); + if (this._manager.isActive()) this._manager.updateWithResults(results); + }); + } + + getUsageInfo() { + var _this$_failedTestAsse; + + if ( + (_this$_failedTestAsse = this._failedTestAssertions) !== null && + _this$_failedTestAsse !== void 0 && + _this$_failedTestAsse.length + ) { + return { + key: 'i', + prompt: 'run failing tests interactively' + }; + } + + return null; + } + + onKey(key) { + if (this._manager.isActive()) { + this._manager.put(key); + } + } + + run(_, updateConfigAndRun) { + return new Promise(resolve => { + if ( + !this._failedTestAssertions || + this._failedTestAssertions.length === 0 + ) { + resolve(); + return; + } + + this._manager.run(this._failedTestAssertions, failure => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: failure ? `^${failure.fullName}$` : '', + testPathPattern: + (failure === null || failure === void 0 ? void 0 : failure.path) || + '' + }); + + if (!this._manager.isActive()) { + resolve(); + } + }); + }); + } + + getFailedTestAssertions(results) { + const failedTestPaths = []; + + if ( + // skip if no failed tests + results.numFailedTests === 0 || // skip if missing test results + !results.testResults || // skip if unmatched snapshots are present + results.snapshot.unmatched + ) { + return failedTestPaths; + } + + results.testResults.forEach(testResult => { + testResult.testResults.forEach(result => { + if (result.status === 'failed') { + failedTestPaths.push({ + fullName: result.fullName, + path: testResult.testFilePath + }); + } + }); + }); + return failedTestPaths; + } +} + +exports.default = FailedTestsInteractivePlugin; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.d.ts new file mode 100644 index 00000000000..e86561247f6 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.d.ts @@ -0,0 +1,18 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// +import { BaseWatchPlugin, UsageData } from 'jest-watcher'; +declare class QuitPlugin extends BaseWatchPlugin { + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + run(): Promise; + getUsageInfo(): UsageData; +} +export default QuitPlugin; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.js b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.js new file mode 100644 index 00000000000..e643a2b6ea7 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/Quit.js @@ -0,0 +1,60 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +class QuitPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, 'isInternal', void 0); + + this.isInternal = true; + } + + async run() { + if (typeof this._stdin.setRawMode === 'function') { + this._stdin.setRawMode(false); + } + + this._stdout.write('\n'); + + process.exit(0); + } + + getUsageInfo() { + return { + key: 'q', + prompt: 'quit watch mode' + }; + } +} + +var _default = QuitPlugin; +exports.default = _default; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts new file mode 100644 index 00000000000..dc0409af126 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.d.ts @@ -0,0 +1,21 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, Prompt, UpdateConfigCallback, UsageData } from 'jest-watcher'; +declare class TestNamePatternPlugin extends BaseWatchPlugin { + _prompt: Prompt; + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + getUsageInfo(): UsageData; + onKey(key: string): void; + run(globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise; +} +export default TestNamePatternPlugin; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.js b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.js new file mode 100644 index 00000000000..ac60851eaac --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestNamePattern.js @@ -0,0 +1,91 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _TestNamePatternPrompt = _interopRequireDefault( + require('../TestNamePatternPrompt') +); + +var _activeFiltersMessage = _interopRequireDefault( + require('../lib/activeFiltersMessage') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +class TestNamePatternPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, '_prompt', void 0); + + _defineProperty(this, 'isInternal', void 0); + + this._prompt = new (_jestWatcher().Prompt)(); + this.isInternal = true; + } + + getUsageInfo() { + return { + key: 't', + prompt: 'filter by a test name regex pattern' + }; + } + + onKey(key) { + this._prompt.put(key); + } + + run(globalConfig, updateConfigAndRun) { + return new Promise((res, rej) => { + const testNamePatternPrompt = new _TestNamePatternPrompt.default( + this._stdout, + this._prompt + ); + testNamePatternPrompt.run( + value => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: value + }); + res(); + }, + rej, + { + header: (0, _activeFiltersMessage.default)(globalConfig) + } + ); + }); + } +} + +var _default = TestNamePatternPlugin; +exports.default = _default; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts new file mode 100644 index 00000000000..9eefab97f5e --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.d.ts @@ -0,0 +1,21 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, UpdateConfigCallback, UsageData } from 'jest-watcher'; +declare class TestPathPatternPlugin extends BaseWatchPlugin { + private _prompt; + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + getUsageInfo(): UsageData; + onKey(key: string): void; + run(globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise; +} +export default TestPathPatternPlugin; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.js b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.js new file mode 100644 index 00000000000..5c5c4b7a23c --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/TestPathPattern.js @@ -0,0 +1,91 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _TestPathPatternPrompt = _interopRequireDefault( + require('../TestPathPatternPrompt') +); + +var _activeFiltersMessage = _interopRequireDefault( + require('../lib/activeFiltersMessage') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +class TestPathPatternPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, '_prompt', void 0); + + _defineProperty(this, 'isInternal', void 0); + + this._prompt = new (_jestWatcher().Prompt)(); + this.isInternal = true; + } + + getUsageInfo() { + return { + key: 'p', + prompt: 'filter by a filename regex pattern' + }; + } + + onKey(key) { + this._prompt.put(key); + } + + run(globalConfig, updateConfigAndRun) { + return new Promise((res, rej) => { + const testPathPatternPrompt = new _TestPathPatternPrompt.default( + this._stdout, + this._prompt + ); + testPathPatternPrompt.run( + value => { + updateConfigAndRun({ + mode: 'watch', + testPathPattern: value + }); + res(); + }, + rej, + { + header: (0, _activeFiltersMessage.default)(globalConfig) + } + ); + }); + } +} + +var _default = TestPathPatternPlugin; +exports.default = _default; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts new file mode 100644 index 00000000000..3eff4c2dfe0 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.d.ts @@ -0,0 +1,21 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +/// +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, JestHookSubscriber, UpdateConfigCallback, UsageData } from 'jest-watcher'; +declare class UpdateSnapshotsPlugin extends BaseWatchPlugin { + private _hasSnapshotFailure; + isInternal: true; + constructor(options: { + stdin: NodeJS.ReadStream; + stdout: NodeJS.WriteStream; + }); + run(_globalConfig: Config.GlobalConfig, updateConfigAndRun: UpdateConfigCallback): Promise; + apply(hooks: JestHookSubscriber): void; + getUsageInfo(): UsageData | null; +} +export default UpdateSnapshotsPlugin; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.js b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.js new file mode 100644 index 00000000000..c2a9de75d73 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshots.js @@ -0,0 +1,70 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +class UpdateSnapshotsPlugin extends _jestWatcher().BaseWatchPlugin { + constructor(options) { + super(options); + + _defineProperty(this, '_hasSnapshotFailure', void 0); + + _defineProperty(this, 'isInternal', void 0); + + this.isInternal = true; + this._hasSnapshotFailure = false; + } + + run(_globalConfig, updateConfigAndRun) { + updateConfigAndRun({ + updateSnapshot: 'all' + }); + return Promise.resolve(false); + } + + apply(hooks) { + hooks.onTestRunComplete(results => { + this._hasSnapshotFailure = results.snapshot.failure; + }); + } + + getUsageInfo() { + if (this._hasSnapshotFailure) { + return { + key: 'u', + prompt: 'update failing snapshots' + }; + } + + return null; + } +} + +var _default = UpdateSnapshotsPlugin; +exports.default = _default; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts new file mode 100644 index 00000000000..c6a60e657ab --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.d.ts @@ -0,0 +1,20 @@ +/** + * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +import type { AggregatedResult, AssertionLocation } from '@jest/test-result'; +import type { Config } from '@jest/types'; +import { BaseWatchPlugin, JestHookSubscriber, UsageData } from 'jest-watcher'; +declare class UpdateSnapshotInteractivePlugin extends BaseWatchPlugin { + private _snapshotInteractiveMode; + private _failedSnapshotTestAssertions; + isInternal: true; + getFailedSnapshotTestAssertions(testResults: AggregatedResult): Array; + apply(hooks: JestHookSubscriber): void; + onKey(key: string): void; + run(_globalConfig: Config.GlobalConfig, updateConfigAndRun: Function): Promise; + getUsageInfo(): UsageData | null; +} +export default UpdateSnapshotInteractivePlugin; diff --git a/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js new file mode 100644 index 00000000000..5346bc35357 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/build/plugins/UpdateSnapshotsInteractive.js @@ -0,0 +1,138 @@ +'use strict'; + +Object.defineProperty(exports, '__esModule', { + value: true +}); +exports.default = void 0; + +function _jestWatcher() { + const data = require('jest-watcher'); + + _jestWatcher = function () { + return data; + }; + + return data; +} + +var _SnapshotInteractiveMode = _interopRequireDefault( + require('../SnapshotInteractiveMode') +); + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : {default: obj}; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} + +class UpdateSnapshotInteractivePlugin extends _jestWatcher().BaseWatchPlugin { + constructor(...args) { + super(...args); + + _defineProperty( + this, + '_snapshotInteractiveMode', + new _SnapshotInteractiveMode.default(this._stdout) + ); + + _defineProperty(this, '_failedSnapshotTestAssertions', []); + + _defineProperty(this, 'isInternal', true); + } + + getFailedSnapshotTestAssertions(testResults) { + const failedTestPaths = []; + + if (testResults.numFailedTests === 0 || !testResults.testResults) { + return failedTestPaths; + } + + testResults.testResults.forEach(testResult => { + if (testResult.snapshot && testResult.snapshot.unmatched) { + testResult.testResults.forEach(result => { + if (result.status === 'failed') { + failedTestPaths.push({ + fullName: result.fullName, + path: testResult.testFilePath + }); + } + }); + } + }); + return failedTestPaths; + } + + apply(hooks) { + hooks.onTestRunComplete(results => { + this._failedSnapshotTestAssertions = + this.getFailedSnapshotTestAssertions(results); + + if (this._snapshotInteractiveMode.isActive()) { + this._snapshotInteractiveMode.updateWithResults(results); + } + }); + } + + onKey(key) { + if (this._snapshotInteractiveMode.isActive()) { + this._snapshotInteractiveMode.put(key); + } + } + + run(_globalConfig, updateConfigAndRun) { + if (this._failedSnapshotTestAssertions.length) { + return new Promise(res => { + this._snapshotInteractiveMode.run( + this._failedSnapshotTestAssertions, + (assertion, shouldUpdateSnapshot) => { + updateConfigAndRun({ + mode: 'watch', + testNamePattern: assertion ? `^${assertion.fullName}$` : '', + testPathPattern: assertion ? assertion.path : '', + updateSnapshot: shouldUpdateSnapshot ? 'all' : 'none' + }); + + if (!this._snapshotInteractiveMode.isActive()) { + res(); + } + } + ); + }); + } else { + return Promise.resolve(); + } + } + + getUsageInfo() { + var _this$_failedSnapshot; + + if ( + ((_this$_failedSnapshot = this._failedSnapshotTestAssertions) === null || + _this$_failedSnapshot === void 0 + ? void 0 + : _this$_failedSnapshot.length) > 0 + ) { + return { + key: 'i', + prompt: 'update failing snapshots interactively' + }; + } + + return null; + } +} + +var _default = UpdateSnapshotInteractivePlugin; +exports.default = _default; diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.d.ts b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.d.ts new file mode 100644 index 00000000000..44a907e580f --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.d.ts @@ -0,0 +1,345 @@ +declare type CSSColor = + | 'aliceblue' + | 'antiquewhite' + | 'aqua' + | 'aquamarine' + | 'azure' + | 'beige' + | 'bisque' + | 'black' + | 'blanchedalmond' + | 'blue' + | 'blueviolet' + | 'brown' + | 'burlywood' + | 'cadetblue' + | 'chartreuse' + | 'chocolate' + | 'coral' + | 'cornflowerblue' + | 'cornsilk' + | 'crimson' + | 'cyan' + | 'darkblue' + | 'darkcyan' + | 'darkgoldenrod' + | 'darkgray' + | 'darkgreen' + | 'darkgrey' + | 'darkkhaki' + | 'darkmagenta' + | 'darkolivegreen' + | 'darkorange' + | 'darkorchid' + | 'darkred' + | 'darksalmon' + | 'darkseagreen' + | 'darkslateblue' + | 'darkslategray' + | 'darkslategrey' + | 'darkturquoise' + | 'darkviolet' + | 'deeppink' + | 'deepskyblue' + | 'dimgray' + | 'dimgrey' + | 'dodgerblue' + | 'firebrick' + | 'floralwhite' + | 'forestgreen' + | 'fuchsia' + | 'gainsboro' + | 'ghostwhite' + | 'gold' + | 'goldenrod' + | 'gray' + | 'green' + | 'greenyellow' + | 'grey' + | 'honeydew' + | 'hotpink' + | 'indianred' + | 'indigo' + | 'ivory' + | 'khaki' + | 'lavender' + | 'lavenderblush' + | 'lawngreen' + | 'lemonchiffon' + | 'lightblue' + | 'lightcoral' + | 'lightcyan' + | 'lightgoldenrodyellow' + | 'lightgray' + | 'lightgreen' + | 'lightgrey' + | 'lightpink' + | 'lightsalmon' + | 'lightseagreen' + | 'lightskyblue' + | 'lightslategray' + | 'lightslategrey' + | 'lightsteelblue' + | 'lightyellow' + | 'lime' + | 'limegreen' + | 'linen' + | 'magenta' + | 'maroon' + | 'mediumaquamarine' + | 'mediumblue' + | 'mediumorchid' + | 'mediumpurple' + | 'mediumseagreen' + | 'mediumslateblue' + | 'mediumspringgreen' + | 'mediumturquoise' + | 'mediumvioletred' + | 'midnightblue' + | 'mintcream' + | 'mistyrose' + | 'moccasin' + | 'navajowhite' + | 'navy' + | 'oldlace' + | 'olive' + | 'olivedrab' + | 'orange' + | 'orangered' + | 'orchid' + | 'palegoldenrod' + | 'palegreen' + | 'paleturquoise' + | 'palevioletred' + | 'papayawhip' + | 'peachpuff' + | 'peru' + | 'pink' + | 'plum' + | 'powderblue' + | 'purple' + | 'rebeccapurple' + | 'red' + | 'rosybrown' + | 'royalblue' + | 'saddlebrown' + | 'salmon' + | 'sandybrown' + | 'seagreen' + | 'seashell' + | 'sienna' + | 'silver' + | 'skyblue' + | 'slateblue' + | 'slategray' + | 'slategrey' + | 'snow' + | 'springgreen' + | 'steelblue' + | 'tan' + | 'teal' + | 'thistle' + | 'tomato' + | 'turquoise' + | 'violet' + | 'wheat' + | 'white' + | 'whitesmoke' + | 'yellow' + | 'yellowgreen'; + +declare namespace ansiStyles { + interface ColorConvert { + /** + The RGB color space. + + @param red - (`0`-`255`) + @param green - (`0`-`255`) + @param blue - (`0`-`255`) + */ + rgb(red: number, green: number, blue: number): string; + + /** + The RGB HEX color space. + + @param hex - A hexadecimal string containing RGB data. + */ + hex(hex: string): string; + + /** + @param keyword - A CSS color name. + */ + keyword(keyword: CSSColor): string; + + /** + The HSL color space. + + @param hue - (`0`-`360`) + @param saturation - (`0`-`100`) + @param lightness - (`0`-`100`) + */ + hsl(hue: number, saturation: number, lightness: number): string; + + /** + The HSV color space. + + @param hue - (`0`-`360`) + @param saturation - (`0`-`100`) + @param value - (`0`-`100`) + */ + hsv(hue: number, saturation: number, value: number): string; + + /** + The HSV color space. + + @param hue - (`0`-`360`) + @param whiteness - (`0`-`100`) + @param blackness - (`0`-`100`) + */ + hwb(hue: number, whiteness: number, blackness: number): string; + + /** + Use a [4-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4-bit) to set text color. + */ + ansi(ansi: number): string; + + /** + Use an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color. + */ + ansi256(ansi: number): string; + } + + interface CSPair { + /** + The ANSI terminal control sequence for starting this style. + */ + readonly open: string; + + /** + The ANSI terminal control sequence for ending this style. + */ + readonly close: string; + } + + interface ColorBase { + readonly ansi: ColorConvert; + readonly ansi256: ColorConvert; + readonly ansi16m: ColorConvert; + + /** + The ANSI terminal control sequence for ending this color. + */ + readonly close: string; + } + + interface Modifier { + /** + Resets the current color chain. + */ + readonly reset: CSPair; + + /** + Make text bold. + */ + readonly bold: CSPair; + + /** + Emitting only a small amount of light. + */ + readonly dim: CSPair; + + /** + Make text italic. (Not widely supported) + */ + readonly italic: CSPair; + + /** + Make text underline. (Not widely supported) + */ + readonly underline: CSPair; + + /** + Inverse background and foreground colors. + */ + readonly inverse: CSPair; + + /** + Prints the text, but makes it invisible. + */ + readonly hidden: CSPair; + + /** + Puts a horizontal line through the center of the text. (Not widely supported) + */ + readonly strikethrough: CSPair; + } + + interface ForegroundColor { + readonly black: CSPair; + readonly red: CSPair; + readonly green: CSPair; + readonly yellow: CSPair; + readonly blue: CSPair; + readonly cyan: CSPair; + readonly magenta: CSPair; + readonly white: CSPair; + + /** + Alias for `blackBright`. + */ + readonly gray: CSPair; + + /** + Alias for `blackBright`. + */ + readonly grey: CSPair; + + readonly blackBright: CSPair; + readonly redBright: CSPair; + readonly greenBright: CSPair; + readonly yellowBright: CSPair; + readonly blueBright: CSPair; + readonly cyanBright: CSPair; + readonly magentaBright: CSPair; + readonly whiteBright: CSPair; + } + + interface BackgroundColor { + readonly bgBlack: CSPair; + readonly bgRed: CSPair; + readonly bgGreen: CSPair; + readonly bgYellow: CSPair; + readonly bgBlue: CSPair; + readonly bgCyan: CSPair; + readonly bgMagenta: CSPair; + readonly bgWhite: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGray: CSPair; + + /** + Alias for `bgBlackBright`. + */ + readonly bgGrey: CSPair; + + readonly bgBlackBright: CSPair; + readonly bgRedBright: CSPair; + readonly bgGreenBright: CSPair; + readonly bgYellowBright: CSPair; + readonly bgBlueBright: CSPair; + readonly bgCyanBright: CSPair; + readonly bgMagentaBright: CSPair; + readonly bgWhiteBright: CSPair; + } +} + +declare const ansiStyles: { + readonly modifier: ansiStyles.Modifier; + readonly color: ansiStyles.ForegroundColor & ansiStyles.ColorBase; + readonly bgColor: ansiStyles.BackgroundColor & ansiStyles.ColorBase; + readonly codes: ReadonlyMap; +} & ansiStyles.BackgroundColor & ansiStyles.ForegroundColor & ansiStyles.Modifier; + +export = ansiStyles; diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.js b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.js new file mode 100644 index 00000000000..5d82581a13f --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/index.js @@ -0,0 +1,163 @@ +'use strict'; + +const wrapAnsi16 = (fn, offset) => (...args) => { + const code = fn(...args); + return `\u001B[${code + offset}m`; +}; + +const wrapAnsi256 = (fn, offset) => (...args) => { + const code = fn(...args); + return `\u001B[${38 + offset};5;${code}m`; +}; + +const wrapAnsi16m = (fn, offset) => (...args) => { + const rgb = fn(...args); + return `\u001B[${38 + offset};2;${rgb[0]};${rgb[1]};${rgb[2]}m`; +}; + +const ansi2ansi = n => n; +const rgb2rgb = (r, g, b) => [r, g, b]; + +const setLazyProperty = (object, property, get) => { + Object.defineProperty(object, property, { + get: () => { + const value = get(); + + Object.defineProperty(object, property, { + value, + enumerable: true, + configurable: true + }); + + return value; + }, + enumerable: true, + configurable: true + }); +}; + +/** @type {typeof import('color-convert')} */ +let colorConvert; +const makeDynamicStyles = (wrap, targetSpace, identity, isBackground) => { + if (colorConvert === undefined) { + colorConvert = require('color-convert'); + } + + const offset = isBackground ? 10 : 0; + const styles = {}; + + for (const [sourceSpace, suite] of Object.entries(colorConvert)) { + const name = sourceSpace === 'ansi16' ? 'ansi' : sourceSpace; + if (sourceSpace === targetSpace) { + styles[name] = wrap(identity, offset); + } else if (typeof suite === 'object') { + styles[name] = wrap(suite[targetSpace], offset); + } + } + + return styles; +}; + +function assembleStyles() { + const codes = new Map(); + const styles = { + modifier: { + reset: [0, 0], + // 21 isn't widely supported and 22 does the same thing + bold: [1, 22], + dim: [2, 22], + italic: [3, 23], + underline: [4, 24], + inverse: [7, 27], + hidden: [8, 28], + strikethrough: [9, 29] + }, + color: { + black: [30, 39], + red: [31, 39], + green: [32, 39], + yellow: [33, 39], + blue: [34, 39], + magenta: [35, 39], + cyan: [36, 39], + white: [37, 39], + + // Bright color + blackBright: [90, 39], + redBright: [91, 39], + greenBright: [92, 39], + yellowBright: [93, 39], + blueBright: [94, 39], + magentaBright: [95, 39], + cyanBright: [96, 39], + whiteBright: [97, 39] + }, + bgColor: { + bgBlack: [40, 49], + bgRed: [41, 49], + bgGreen: [42, 49], + bgYellow: [43, 49], + bgBlue: [44, 49], + bgMagenta: [45, 49], + bgCyan: [46, 49], + bgWhite: [47, 49], + + // Bright color + bgBlackBright: [100, 49], + bgRedBright: [101, 49], + bgGreenBright: [102, 49], + bgYellowBright: [103, 49], + bgBlueBright: [104, 49], + bgMagentaBright: [105, 49], + bgCyanBright: [106, 49], + bgWhiteBright: [107, 49] + } + }; + + // Alias bright black as gray (and grey) + styles.color.gray = styles.color.blackBright; + styles.bgColor.bgGray = styles.bgColor.bgBlackBright; + styles.color.grey = styles.color.blackBright; + styles.bgColor.bgGrey = styles.bgColor.bgBlackBright; + + for (const [groupName, group] of Object.entries(styles)) { + for (const [styleName, style] of Object.entries(group)) { + styles[styleName] = { + open: `\u001B[${style[0]}m`, + close: `\u001B[${style[1]}m` + }; + + group[styleName] = styles[styleName]; + + codes.set(style[0], style[1]); + } + + Object.defineProperty(styles, groupName, { + value: group, + enumerable: false + }); + } + + Object.defineProperty(styles, 'codes', { + value: codes, + enumerable: false + }); + + styles.color.close = '\u001B[39m'; + styles.bgColor.close = '\u001B[49m'; + + setLazyProperty(styles.color, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, false)); + setLazyProperty(styles.color, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, false)); + setLazyProperty(styles.color, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, false)); + setLazyProperty(styles.bgColor, 'ansi', () => makeDynamicStyles(wrapAnsi16, 'ansi16', ansi2ansi, true)); + setLazyProperty(styles.bgColor, 'ansi256', () => makeDynamicStyles(wrapAnsi256, 'ansi256', ansi2ansi, true)); + setLazyProperty(styles.bgColor, 'ansi16m', () => makeDynamicStyles(wrapAnsi16m, 'rgb', rgb2rgb, true)); + + return styles; +} + +// Make the export immutable +Object.defineProperty(module, 'exports', { + enumerable: true, + get: assembleStyles +}); diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/license b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/license new file mode 100644 index 00000000000..e7af2f77107 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/package.json b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/package.json new file mode 100644 index 00000000000..75393284d7e --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/package.json @@ -0,0 +1,56 @@ +{ + "name": "ansi-styles", + "version": "4.3.0", + "description": "ANSI escape codes for styling strings in the terminal", + "license": "MIT", + "repository": "chalk/ansi-styles", + "funding": "https://github.com/chalk/ansi-styles?sponsor=1", + "author": { + "name": "Sindre Sorhus", + "email": "sindresorhus@gmail.com", + "url": "sindresorhus.com" + }, + "engines": { + "node": ">=8" + }, + "scripts": { + "test": "xo && ava && tsd", + "screenshot": "svg-term --command='node screenshot' --out=screenshot.svg --padding=3 --width=55 --height=3 --at=1000 --no-cursor" + }, + "files": [ + "index.js", + "index.d.ts" + ], + "keywords": [ + "ansi", + "styles", + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "tty", + "escape", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "dependencies": { + "color-convert": "^2.0.1" + }, + "devDependencies": { + "@types/color-convert": "^1.9.0", + "ava": "^2.3.0", + "svg-term-cli": "^2.1.1", + "tsd": "^0.11.0", + "xo": "^0.25.3" + } +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/readme.md b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/readme.md new file mode 100644 index 00000000000..24883de808b --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/ansi-styles/readme.md @@ -0,0 +1,152 @@ +# ansi-styles [![Build Status](https://travis-ci.org/chalk/ansi-styles.svg?branch=master)](https://travis-ci.org/chalk/ansi-styles) + +> [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles) for styling strings in the terminal + +You probably want the higher-level [chalk](https://github.com/chalk/chalk) module for styling your strings. + + + +## Install + +``` +$ npm install ansi-styles +``` + +## Usage + +```js +const style = require('ansi-styles'); + +console.log(`${style.green.open}Hello world!${style.green.close}`); + + +// Color conversion between 16/256/truecolor +// NOTE: If conversion goes to 16 colors or 256 colors, the original color +// may be degraded to fit that color palette. This means terminals +// that do not support 16 million colors will best-match the +// original color. +console.log(style.bgColor.ansi.hsl(120, 80, 72) + 'Hello world!' + style.bgColor.close); +console.log(style.color.ansi256.rgb(199, 20, 250) + 'Hello world!' + style.color.close); +console.log(style.color.ansi16m.hex('#abcdef') + 'Hello world!' + style.color.close); +``` + +## API + +Each style has an `open` and `close` property. + +## Styles + +### Modifiers + +- `reset` +- `bold` +- `dim` +- `italic` *(Not widely supported)* +- `underline` +- `inverse` +- `hidden` +- `strikethrough` *(Not widely supported)* + +### Colors + +- `black` +- `red` +- `green` +- `yellow` +- `blue` +- `magenta` +- `cyan` +- `white` +- `blackBright` (alias: `gray`, `grey`) +- `redBright` +- `greenBright` +- `yellowBright` +- `blueBright` +- `magentaBright` +- `cyanBright` +- `whiteBright` + +### Background colors + +- `bgBlack` +- `bgRed` +- `bgGreen` +- `bgYellow` +- `bgBlue` +- `bgMagenta` +- `bgCyan` +- `bgWhite` +- `bgBlackBright` (alias: `bgGray`, `bgGrey`) +- `bgRedBright` +- `bgGreenBright` +- `bgYellowBright` +- `bgBlueBright` +- `bgMagentaBright` +- `bgCyanBright` +- `bgWhiteBright` + +## Advanced usage + +By default, you get a map of styles, but the styles are also available as groups. They are non-enumerable so they don't show up unless you access them explicitly. This makes it easier to expose only a subset in a higher-level module. + +- `style.modifier` +- `style.color` +- `style.bgColor` + +###### Example + +```js +console.log(style.color.green.open); +``` + +Raw escape codes (i.e. without the CSI escape prefix `\u001B[` and render mode postfix `m`) are available under `style.codes`, which returns a `Map` with the open codes as keys and close codes as values. + +###### Example + +```js +console.log(style.codes.get(36)); +//=> 39 +``` + +## [256 / 16 million (TrueColor) support](https://gist.github.com/XVilka/8346728) + +`ansi-styles` uses the [`color-convert`](https://github.com/Qix-/color-convert) package to allow for converting between various colors and ANSI escapes, with support for 256 and 16 million colors. + +The following color spaces from `color-convert` are supported: + +- `rgb` +- `hex` +- `keyword` +- `hsl` +- `hsv` +- `hwb` +- `ansi` +- `ansi256` + +To use these, call the associated conversion function with the intended output, for example: + +```js +style.color.ansi.rgb(100, 200, 15); // RGB to 16 color ansi foreground code +style.bgColor.ansi.rgb(100, 200, 15); // RGB to 16 color ansi background code + +style.color.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code +style.bgColor.ansi256.hsl(120, 100, 60); // HSL to 256 color ansi foreground code + +style.color.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color foreground code +style.bgColor.ansi16m.hex('#C0FFEE'); // Hex (RGB) to 16 million color background code +``` + +## Related + +- [ansi-escapes](https://github.com/sindresorhus/ansi-escapes) - ANSI escape codes for manipulating the terminal + +## Maintainers + +- [Sindre Sorhus](https://github.com/sindresorhus) +- [Josh Junon](https://github.com/qix-) + +## For enterprise + +Available as part of the Tidelift Subscription. + +The maintainers of `ansi-styles` and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-ansi-styles?utm_source=npm-ansi-styles&utm_medium=referral&utm_campaign=enterprise&utm_term=repo) diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/index.d.ts b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/index.d.ts new file mode 100644 index 00000000000..9cd88f38bee --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/index.d.ts @@ -0,0 +1,415 @@ +/** +Basic foreground colors. + +[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support) +*/ +declare type ForegroundColor = + | 'black' + | 'red' + | 'green' + | 'yellow' + | 'blue' + | 'magenta' + | 'cyan' + | 'white' + | 'gray' + | 'grey' + | 'blackBright' + | 'redBright' + | 'greenBright' + | 'yellowBright' + | 'blueBright' + | 'magentaBright' + | 'cyanBright' + | 'whiteBright'; + +/** +Basic background colors. + +[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support) +*/ +declare type BackgroundColor = + | 'bgBlack' + | 'bgRed' + | 'bgGreen' + | 'bgYellow' + | 'bgBlue' + | 'bgMagenta' + | 'bgCyan' + | 'bgWhite' + | 'bgGray' + | 'bgGrey' + | 'bgBlackBright' + | 'bgRedBright' + | 'bgGreenBright' + | 'bgYellowBright' + | 'bgBlueBright' + | 'bgMagentaBright' + | 'bgCyanBright' + | 'bgWhiteBright'; + +/** +Basic colors. + +[More colors here.](https://github.com/chalk/chalk/blob/master/readme.md#256-and-truecolor-color-support) +*/ +declare type Color = ForegroundColor | BackgroundColor; + +declare type Modifiers = + | 'reset' + | 'bold' + | 'dim' + | 'italic' + | 'underline' + | 'inverse' + | 'hidden' + | 'strikethrough' + | 'visible'; + +declare namespace chalk { + /** + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + type Level = 0 | 1 | 2 | 3; + + interface Options { + /** + Specify the color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + level?: Level; + } + + /** + Return a new Chalk instance. + */ + type Instance = new (options?: Options) => Chalk; + + /** + Detect whether the terminal supports color. + */ + interface ColorSupport { + /** + The color level used by Chalk. + */ + level: Level; + + /** + Return whether Chalk supports basic 16 colors. + */ + hasBasic: boolean; + + /** + Return whether Chalk supports ANSI 256 colors. + */ + has256: boolean; + + /** + Return whether Chalk supports Truecolor 16 million colors. + */ + has16m: boolean; + } + + interface ChalkFunction { + /** + Use a template string. + + @remarks Template literals are unsupported for nested calls (see [issue #341](https://github.com/chalk/chalk/issues/341)) + + @example + ``` + import chalk = require('chalk'); + + log(chalk` + CPU: {red ${cpu.totalPercent}%} + RAM: {green ${ram.used / ram.total * 100}%} + DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%} + `); + ``` + + @example + ``` + import chalk = require('chalk'); + + log(chalk.red.bgBlack`2 + 3 = {bold ${2 + 3}}`) + ``` + */ + (text: TemplateStringsArray, ...placeholders: unknown[]): string; + + (...text: unknown[]): string; + } + + interface Chalk extends ChalkFunction { + /** + Return a new Chalk instance. + */ + Instance: Instance; + + /** + The color support for Chalk. + + By default, color support is automatically detected based on the environment. + + Levels: + - `0` - All colors disabled. + - `1` - Basic 16 colors support. + - `2` - ANSI 256 colors support. + - `3` - Truecolor 16 million colors support. + */ + level: Level; + + /** + Use HEX value to set text color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk = require('chalk'); + + chalk.hex('#DEADED'); + ``` + */ + hex(color: string): Chalk; + + /** + Use keyword color value to set text color. + + @param color - Keyword value representing the desired color. + + @example + ``` + import chalk = require('chalk'); + + chalk.keyword('orange'); + ``` + */ + keyword(color: string): Chalk; + + /** + Use RGB values to set text color. + */ + rgb(red: number, green: number, blue: number): Chalk; + + /** + Use HSL values to set text color. + */ + hsl(hue: number, saturation: number, lightness: number): Chalk; + + /** + Use HSV values to set text color. + */ + hsv(hue: number, saturation: number, value: number): Chalk; + + /** + Use HWB values to set text color. + */ + hwb(hue: number, whiteness: number, blackness: number): Chalk; + + /** + Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set text color. + + 30 <= code && code < 38 || 90 <= code && code < 98 + For example, 31 for red, 91 for redBright. + */ + ansi(code: number): Chalk; + + /** + Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color. + */ + ansi256(index: number): Chalk; + + /** + Use HEX value to set background color. + + @param color - Hexadecimal value representing the desired color. + + @example + ``` + import chalk = require('chalk'); + + chalk.bgHex('#DEADED'); + ``` + */ + bgHex(color: string): Chalk; + + /** + Use keyword color value to set background color. + + @param color - Keyword value representing the desired color. + + @example + ``` + import chalk = require('chalk'); + + chalk.bgKeyword('orange'); + ``` + */ + bgKeyword(color: string): Chalk; + + /** + Use RGB values to set background color. + */ + bgRgb(red: number, green: number, blue: number): Chalk; + + /** + Use HSL values to set background color. + */ + bgHsl(hue: number, saturation: number, lightness: number): Chalk; + + /** + Use HSV values to set background color. + */ + bgHsv(hue: number, saturation: number, value: number): Chalk; + + /** + Use HWB values to set background color. + */ + bgHwb(hue: number, whiteness: number, blackness: number): Chalk; + + /** + Use a [Select/Set Graphic Rendition](https://en.wikipedia.org/wiki/ANSI_escape_code#SGR_parameters) (SGR) [color code number](https://en.wikipedia.org/wiki/ANSI_escape_code#3/4_bit) to set background color. + + 30 <= code && code < 38 || 90 <= code && code < 98 + For example, 31 for red, 91 for redBright. + Use the foreground code, not the background code (for example, not 41, nor 101). + */ + bgAnsi(code: number): Chalk; + + /** + Use a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color. + */ + bgAnsi256(index: number): Chalk; + + /** + Modifier: Resets the current color chain. + */ + readonly reset: Chalk; + + /** + Modifier: Make text bold. + */ + readonly bold: Chalk; + + /** + Modifier: Emitting only a small amount of light. + */ + readonly dim: Chalk; + + /** + Modifier: Make text italic. (Not widely supported) + */ + readonly italic: Chalk; + + /** + Modifier: Make text underline. (Not widely supported) + */ + readonly underline: Chalk; + + /** + Modifier: Inverse background and foreground colors. + */ + readonly inverse: Chalk; + + /** + Modifier: Prints the text, but makes it invisible. + */ + readonly hidden: Chalk; + + /** + Modifier: Puts a horizontal line through the center of the text. (Not widely supported) + */ + readonly strikethrough: Chalk; + + /** + Modifier: Prints the text only when Chalk has a color support level > 0. + Can be useful for things that are purely cosmetic. + */ + readonly visible: Chalk; + + readonly black: Chalk; + readonly red: Chalk; + readonly green: Chalk; + readonly yellow: Chalk; + readonly blue: Chalk; + readonly magenta: Chalk; + readonly cyan: Chalk; + readonly white: Chalk; + + /* + Alias for `blackBright`. + */ + readonly gray: Chalk; + + /* + Alias for `blackBright`. + */ + readonly grey: Chalk; + + readonly blackBright: Chalk; + readonly redBright: Chalk; + readonly greenBright: Chalk; + readonly yellowBright: Chalk; + readonly blueBright: Chalk; + readonly magentaBright: Chalk; + readonly cyanBright: Chalk; + readonly whiteBright: Chalk; + + readonly bgBlack: Chalk; + readonly bgRed: Chalk; + readonly bgGreen: Chalk; + readonly bgYellow: Chalk; + readonly bgBlue: Chalk; + readonly bgMagenta: Chalk; + readonly bgCyan: Chalk; + readonly bgWhite: Chalk; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGray: Chalk; + + /* + Alias for `bgBlackBright`. + */ + readonly bgGrey: Chalk; + + readonly bgBlackBright: Chalk; + readonly bgRedBright: Chalk; + readonly bgGreenBright: Chalk; + readonly bgYellowBright: Chalk; + readonly bgBlueBright: Chalk; + readonly bgMagentaBright: Chalk; + readonly bgCyanBright: Chalk; + readonly bgWhiteBright: Chalk; + } +} + +/** +Main Chalk object that allows to chain styles together. +Call the last one as a method with a string argument. +Order doesn't matter, and later styles take precedent in case of a conflict. +This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`. +*/ +declare const chalk: chalk.Chalk & chalk.ChalkFunction & { + supportsColor: chalk.ColorSupport | false; + Level: chalk.Level; + Color: Color; + ForegroundColor: ForegroundColor; + BackgroundColor: BackgroundColor; + Modifiers: Modifiers; + stderr: chalk.Chalk & {supportsColor: chalk.ColorSupport | false}; +}; + +export = chalk; diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/license b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/license new file mode 100644 index 00000000000..e7af2f77107 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/license @@ -0,0 +1,9 @@ +MIT License + +Copyright (c) Sindre Sorhus (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/package.json b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/package.json new file mode 100644 index 00000000000..47c23f29068 --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/package.json @@ -0,0 +1,68 @@ +{ + "name": "chalk", + "version": "4.1.2", + "description": "Terminal string styling done right", + "license": "MIT", + "repository": "chalk/chalk", + "funding": "https://github.com/chalk/chalk?sponsor=1", + "main": "source", + "engines": { + "node": ">=10" + }, + "scripts": { + "test": "xo && nyc ava && tsd", + "bench": "matcha benchmark.js" + }, + "files": [ + "source", + "index.d.ts" + ], + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "str", + "ansi", + "style", + "styles", + "tty", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "devDependencies": { + "ava": "^2.4.0", + "coveralls": "^3.0.7", + "execa": "^4.0.0", + "import-fresh": "^3.1.0", + "matcha": "^0.7.0", + "nyc": "^15.0.0", + "resolve-from": "^5.0.0", + "tsd": "^0.7.4", + "xo": "^0.28.2" + }, + "xo": { + "rules": { + "unicorn/prefer-string-slice": "off", + "unicorn/prefer-includes": "off", + "@typescript-eslint/member-ordering": "off", + "no-redeclare": "off", + "unicorn/string-content": "off", + "unicorn/better-regex": "off" + } + } +} diff --git a/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/readme.md b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/readme.md new file mode 100644 index 00000000000..a055d21c97e --- /dev/null +++ b/src/DynamoSandbox/node_modules/@jest/core/node_modules/chalk/readme.md @@ -0,0 +1,341 @@ +

+
+
+ Chalk +
+
+
+

+ +> Terminal string styling done right + +[![Build Status](https://travis-ci.org/chalk/chalk.svg?branch=master)](https://travis-ci.org/chalk/chalk) [![Coverage Status](https://coveralls.io/repos/github/chalk/chalk/badge.svg?branch=master)](https://coveralls.io/github/chalk/chalk?branch=master) [![npm dependents](https://badgen.net/npm/dependents/chalk)](https://www.npmjs.com/package/chalk?activeTab=dependents) [![Downloads](https://badgen.net/npm/dt/chalk)](https://www.npmjs.com/package/chalk) [![](https://img.shields.io/badge/unicorn-approved-ff69b4.svg)](https://www.youtube.com/watch?v=9auOCbH5Ns4) [![XO code style](https://img.shields.io/badge/code_style-XO-5ed9c7.svg)](https://github.com/xojs/xo) ![TypeScript-ready](https://img.shields.io/npm/types/chalk.svg) [![run on repl.it](https://repl.it/badge/github/chalk/chalk)](https://repl.it/github/chalk/chalk) + + + +
+ +--- + + + +--- + +
+ +## Highlights + +- Expressive API +- Highly performant +- Ability to nest styles +- [256/Truecolor color support](#256-and-truecolor-color-support) +- Auto-detects color support +- Doesn't extend `String.prototype` +- Clean and focused +- Actively maintained +- [Used by ~50,000 packages](https://www.npmjs.com/browse/depended/chalk) as of January 1, 2020 + +## Install + +```console +$ npm install chalk +``` + +## Usage + +```js +const chalk = require('chalk'); + +console.log(chalk.blue('Hello world!')); +``` + +Chalk comes with an easy to use composable API where you just chain and nest the styles you want. + +```js +const chalk = require('chalk'); +const log = console.log; + +// Combine styled and normal strings +log(chalk.blue('Hello') + ' World' + chalk.red('!')); + +// Compose multiple styles using the chainable API +log(chalk.blue.bgRed.bold('Hello world!')); + +// Pass in multiple arguments +log(chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz')); + +// Nest styles +log(chalk.red('Hello', chalk.underline.bgBlue('world') + '!')); + +// Nest styles of the same type even (color, underline, background) +log(chalk.green( + 'I am a green line ' + + chalk.blue.underline.bold('with a blue substring') + + ' that becomes green again!' +)); + +// ES2015 template literal +log(` +CPU: ${chalk.red('90%')} +RAM: ${chalk.green('40%')} +DISK: ${chalk.yellow('70%')} +`); + +// ES2015 tagged template literal +log(chalk` +CPU: {red ${cpu.totalPercent}%} +RAM: {green ${ram.used / ram.total * 100}%} +DISK: {rgb(255,131,0) ${disk.used / disk.total * 100}%} +`); + +// Use RGB colors in terminal emulators that support it. +log(chalk.keyword('orange')('Yay for orange colored text!')); +log(chalk.rgb(123, 45, 67).underline('Underlined reddish color')); +log(chalk.hex('#DEADED').bold('Bold gray!')); +``` + +Easily define your own themes: + +```js +const chalk = require('chalk'); + +const error = chalk.bold.red; +const warning = chalk.keyword('orange'); + +console.log(error('Error!')); +console.log(warning('Warning!')); +``` + +Take advantage of console.log [string substitution](https://nodejs.org/docs/latest/api/console.html#console_console_log_data_args): + +```js +const name = 'Sindre'; +console.log(chalk.green('Hello %s'), name); +//=> 'Hello Sindre' +``` + +## API + +### chalk.`