feature: add ability to move across divisions instead of only within

Author: frankelavsky

app/static-bundle.js

@@ -785,6 +785,85 @@ buildGraph(
     ['any-exit']
 );
 
+let stackedStructure = dataNavigator.structure({
+    data: largerData,
+    idKey: 'id',
+    addIds: true,
+    dimensions: {
+        values: [
+            {
+                dimensionKey: 'date',
+                type: 'categorical',
+                behavior: {
+                    extents: 'circular',
+                    childmostNavigation: 'across'
+                },
+                operations: {
+                    sortFunction: (a, b, c) => {
+                        if (a.values) {
+                            let aDate = new Date(a.values[Object.keys(a.values)[0]].date);
+                            let bDate = new Date(b.values[Object.keys(b.values)[0]].date);
+                            return aDate - bDate;
+                        } else {
+                            return;
+                        }
+                    }
+                }
+            },
+            {
+                dimensionKey: 'category',
+                type: 'categorical',
+                divisionOptions: {
+                    divisionNodeIds: (dimensionKey, keyValue, i) => {
+                        return createValidId(dimensionKey + keyValue + i);
+                    }
+                },
+                behavior: {
+                    extents: 'circular',
+                    childmostNavigation: 'across'
+                }
+            }
+            // {
+            //     dimensionKey: 'value',
+            //     type: 'numerical',
+            //     behavior: {
+            //         extents: 'terminal'
+            //     }
+            // },
+            // {
+            //     dimensionKey: 'count',
+            //     type: 'numerical',
+            //     behavior: {
+            //         extents: 'terminal'
+            //     }
+            // }
+        ]
+    },
+    genericEdges: [
+        {
+            edgeId: 'any-exit',
+            edge: {
+                source: (_d, c) => c,
+                target: () => {
+                    exit['larger']();
+                    return '';
+                },
+                navigationRules: ['exit']
+            }
+        }
+    ]
+});
+console.log('stackedStructure', stackedStructure);
+buildGraph(
+    stackedStructure,
+    'stacked',
+    300,
+    'dimensionLevel',
+    largerStructure.dimensions[Object.keys(largerStructure.dimensions)[0]].nodeId,
+    ['exit'],
+    ['any-exit']
+);
+
 const sparseCategoryTest = [
     {
         cat: 'meow',
@@ -842,7 +921,6 @@ buildGraph(
     ['any-exit']
 );
 
-
 let listStructure = dataNavigator.structure({
     data: sparseCategoryTest,
     idKey: 'catKey',
@@ -857,7 +935,7 @@ let listStructure = dataNavigator.structure({
                     extents: 'circular'
                 },
                 operations: {
-                    compressSparseDivisions: true,
+                    compressSparseDivisions: true
                 }
             }
         ]

app/testing-bundle.js

@@ -98,7 +98,7 @@ export type DimensionObject = {
     dimensionKey: DimensionKey;
     divisions: DimensionDivisions;
     operations: {
-        compressSparseDivisions: boolean;  // if no division more than 1 child, create 1 division with all children, runs after filtering and sorting
+        compressSparseDivisions: boolean; // if no division more than 1 child, create 1 division with all children, runs after filtering and sorting
         sortFunction?: SortingFunction; // by default sorts numerical in ascending, does not sort categorical
     };
     behavior?: DimensionBehavior;
@@ -198,6 +198,8 @@ export type DimensionBehavior = {
     extents: ExtentType;
     customBridgePrevious?: NodeId;
     customBridgePost?: NodeId;
+    childmostNavigation?: ChildmostNavigationStrategy;
+    childmostMatching?: ChildmostMatchingStrategy;
 };
 
 export type Level1Behavior = {
@@ -252,6 +254,13 @@ export type DynamicDimensionRenderId = ((d?: DimensionDatum, a?: GenericDataset)
 
 export type NumericallySubdivide = ((d?: DimensionKey, n?: Nodes) => number) | number;
 
+export type ChildmostMatchingStrategy = (
+    index?: number,
+    currentDivisionChild?: DatumObject,
+    currentDivision?: DivisionObject,
+    nextDivision?: DivisionObject
+) => DatumObject | undefined;
+
 export type AdjustingFunction = (d: Dimensions) => Dimensions;
 
 export type SortingFunction = (a: DatumObject, b: DatumObject, c?: any) => number;
@@ -282,6 +291,8 @@ export type DimensionType = 'numerical' | 'categorical';
 
 export type ExtentType = 'circular' | 'terminal' | 'bridgedCousins' | 'bridgedCustom';
 
+export type ChildmostNavigationStrategy = 'within' | 'across';
+
 export type Level0ExtentType = 'circular' | 'terminal' | 'bridgedCustom';
 
 export type DataType = 'vega-lite' | 'vl' | 'Vega-Lite' | 'generic' | 'default';