Replace GetSetReturn with function overloading.

finos · Dec 15, 2023 · 08ebe71 · 08ebe71
1 parent 8eb1ece
commit 08ebe71
Show file tree

Hide file tree

Showing 24 changed files with 475 additions and 681 deletions.
diff --git a/packages/perspective-viewer-d3fc/src/ts/axis/axisFactory.ts b/packages/perspective-viewer-d3fc/src/ts/axis/axisFactory.ts
@@ -22,7 +22,6 @@ import {
     D3Scale,
     Domain,
     DomainTuple,
-    GetSetReturn,
     Orientation,
     SettingNameValues,
     Settings,
@@ -50,30 +49,29 @@ export interface AxisFactoryContent {
 
 interface AxisFactory {
     (data: any[]): any;
-    memoValue: <T extends Axis | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, Axis, AxisFactory>;
-    excludeType: <T extends string | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, string, AxisFactory>;
-    orient: <T extends Orientation | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, Orientation, AxisFactory>;
-    settingName: <T extends SettingNameValues | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, SettingNameValues, AxisFactory>;
-    settingValue: <T extends string | null | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, string | null, AxisFactory>;
-    valueName: <T extends ValueName | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, ValueName, AxisFactory>;
-    valueNames: <T extends ValueName[] | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, ValueName[], AxisFactory>;
-    modifyDomain: <T extends ModifyDomainFunc | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, ModifyDomainFunc, AxisFactory>;
+    memoValue(): Axis;
+    memoValue(a: Axis): AxisFactory;
+
+    excludeType(): () => AxisTypeValues;
+    excludeType(nextExcludeType?: AxisTypeValues): this;
+
+    orient(): () => Orientation;
+    orient(nextOrient?: Orientation): this;
+
+    settingName(): () => SettingNameValues;
+    settingName(nextSettingName?: SettingNameValues): this;
+
+    settingValue(): () => string | null;
+    settingValue(nextSettingValue?: string | null): this;
+
+    valueName(): () => ValueName;
+    valueName(nextValueName?: ValueName): this;
+
+    valueNames(): () => ValueName[];
+    valueNames(nextValueNames?: ValueName[]): this;
+
+    modifyDomain(): () => ModifyDomainFunc;
+    modifyDomain(nextModifyDomain?: ModifyDomainFunc): this;
 
     // optional params, no idea yet if these are right or not.
     include?: (nextInclude?: number[]) => any;
@@ -102,7 +100,7 @@ export const axisFactory = (settings: Settings): AxisFactory => {
     const optionalParams = ["include", "paddingStrategy", "pad"];
     const optional = {};
 
-    const _factory: any = (data): AxisFactoryContent => {
+    const _factory: Partial<AxisFactory> = (data): AxisFactoryContent => {
         const useType = axisType(settings)
             .excludeType(excludeType)
             .settingName(settingName)
@@ -167,95 +165,75 @@ export const axisFactory = (settings: Settings): AxisFactory => {
         decorate: () => {},
     });
 
-    _factory.memoValue = <T extends Axis | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, Axis, AxisFactory> => {
+    _factory.memoValue = (...args: Axis[]): any => {
         if (!args.length) {
-            return memoValue as GetSetReturn<T, Axis, AxisFactory>;
+            return memoValue;
         }
+
         memoValue = args[0];
         return _factory;
     };
 
-    _factory.excludeType = <T extends AxisTypeValues | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, string, AxisFactory> => {
+    _factory.excludeType = (...args: AxisTypeValues[]): any => {
         if (!args.length) {
-            return excludeType as GetSetReturn<T, string, AxisFactory>;
+            return excludeType;
         }
+
         excludeType = args[0];
         return _factory;
     };
 
-    _factory.orient = <T extends Orientation | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, Orientation, AxisFactory> => {
+    _factory.orient = (...args: Orientation[]): any => {
         if (!args.length) {
-            return orient as GetSetReturn<T, Orientation, AxisFactory>;
+            return orient;
         }
+
         orient = args[0];
         return _factory;
     };
 
-    _factory.settingName = <
-        T extends SettingNameValues | undefined = undefined
-    >(
-        ...args: T[]
-    ): GetSetReturn<T, SettingNameValues, AxisFactory> => {
+    _factory.settingName = (...args: SettingNameValues[]): any => {
         if (!args.length) {
-            return settingName as GetSetReturn<
-                T,
-                SettingNameValues,
-                AxisFactory
-            >;
+            return settingName;
         }
+
         settingName = args[0];
         return _factory;
     };
 
-    _factory.settingValue = <T extends string | null | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, string | null, AxisFactory> => {
+    _factory.settingValue = (...args: (string | null)[]): any => {
         if (!args.length) {
-            return settingValue as GetSetReturn<T, string | null, AxisFactory>;
+            return settingValue;
         }
+
         settingValue = args[0];
         return _factory;
     };
 
-    _factory.valueName = <T extends ValueName | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, ValueName, AxisFactory> => {
+    _factory.valueName = (...args: ValueName[]): any => {
         if (!args.length) {
-            return valueNames[0] as GetSetReturn<T, ValueName, AxisFactory>;
+            return valueNames[0];
         }
+
         valueNames = [args[0]];
         return _factory;
     };
 
-    _factory.valueNames = <T extends ValueName[] | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, ValueName[], AxisFactory> => {
+    _factory.valueNames = (...args: ValueName[][]): any => {
         if (!args.length) {
-            return valueNames as GetSetReturn<T, ValueName[], AxisFactory>;
+            return valueNames;
         }
+
         valueNames = args[0];
         return _factory;
     };
 
-    _factory.modifyDomain = <
-        T extends ModifyDomainFunc | undefined = undefined
-    >(
-        ...args: T[]
-    ): GetSetReturn<T, ModifyDomainFunc, AxisFactory> => {
-        if (!args.length) {
-            return modifyDomain as GetSetReturn<
-                T,
-                ModifyDomainFunc,
-                AxisFactory
-            >;
+    _factory.modifyDomain = (nextModifyDomain?: ModifyDomainFunc) => {
+        if (!nextModifyDomain) {
+            return modifyDomain;
         }
-        modifyDomain = args[0];
+
+        modifyDomain = nextModifyDomain;
         return _factory;
     };
 
@@ -269,5 +247,5 @@ export const axisFactory = (settings: Settings): AxisFactory => {
         };
     });
 
-    return _factory;
+    return _factory as AxisFactory;
 };
diff --git a/packages/perspective-viewer-d3fc/src/ts/axis/axisLabel.ts b/packages/perspective-viewer-d3fc/src/ts/axis/axisLabel.ts
@@ -16,7 +16,7 @@ import { labelFunction as noLabel } from "./noAxis";
 import { labelFunction as timeLabel } from "./timeAxis";
 import { labelFunction as linearLabel } from "./linearAxis";
 import { labelFunction as ordinalLabel } from "./ordinalAxis";
-import { GetSetReturn, Settings } from "../types";
+import { Settings } from "../types";
 
 const labelFunctions = {
     none: noLabel,
@@ -28,30 +28,28 @@ const labelFunctions = {
 export interface LabelFunction {
     // NOTE: this "i" is not used...
     (d, i?: any): string;
-    valueName: <T extends string | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, string, LabelFunction>;
+    valueName(): string;
+    valueName(nextValueName: string): this;
 }
 
 export const labelFunction = (settings: Settings): LabelFunction => {
     const base = axisType(settings);
     let valueName = "__ROW_PATH__";
 
-    const label: any = (d, _i) => {
+    const label: Partial<LabelFunction> = (d, _i) => {
         return labelFunctions[base()](valueName)(d);
     };
 
     rebindAll(label, base);
 
-    label.valueName = <T extends string | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, string, LabelFunction> => {
+    label.valueName = (...args: string[]): any => {
         if (!args.length) {
-            return valueName as GetSetReturn<T, string, LabelFunction>;
+            return valueName;
         }
+
         valueName = args[0];
         return label;
     };
 
-    return label;
+    return label as LabelFunction;
 };
diff --git a/packages/perspective-viewer-d3fc/src/ts/axis/axisSplitter.ts b/packages/perspective-viewer-d3fc/src/ts/axis/axisSplitter.ts
@@ -10,21 +10,22 @@
 // ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
 // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
 
-import { GetSetReturn, Settings } from "../types";
+import { Settings } from "../types";
 import { splitterLabels } from "./splitterLabels";
 
 export interface AxisSplitter {
     (selection: any): void;
-    color: <T extends d3.ScaleOrdinal<string, unknown> | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, d3.ScaleOrdinal<string, unknown>, AxisSplitter>;
+
+    color(): d3.ScaleOrdinal<string, unknown>;
+    color(nextColor: d3.ScaleOrdinal<string, unknown>): AxisSplitter;
+
     haveSplit: () => boolean;
-    data: <T extends any[] | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, any[], AxisSplitter>;
-    altData: <T extends any[] | undefined = undefined>(
-        ...args: T[]
-    ) => GetSetReturn<T, any[], AxisSplitter>;
+
+    data(): any[];
+    data(nextData: any[]): AxisSplitter;
+
+    altData(): any[];
+    altData(nextData: any[]): AxisSplitter;
 }
 
 export const axisSplitter = (
@@ -74,38 +75,27 @@ export const axisSplitter = (
             .call(labeller().labels(altLabels).alt(true));
     };
 
-    splitter.color = <
-        T extends d3.ScaleOrdinal<string, unknown> | undefined = undefined
-    >(
-        ...args: T[]
-    ): GetSetReturn<T, d3.ScaleOrdinal<string, unknown>, AxisSplitter> => {
+    splitter.color = (...args: d3.ScaleOrdinal<string, unknown>[]): any => {
         if (!args.length) {
-            return color as GetSetReturn<
-                T,
-                d3.ScaleOrdinal<string, unknown>,
-                AxisSplitter
-            >;
+            return color;
         }
         color = args[0];
         return splitter;
     };
 
     splitter.haveSplit = (): boolean => haveSplit;
 
-    splitter.data = <T extends any[] | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, any[], AxisSplitter> => {
+    splitter.data = (...args: any[][]): any => {
         if (!args.length) {
-            return data as GetSetReturn<T, any[], AxisSplitter>;
+            return data;
         }
         data = args[0];
         return splitter;
     };
-    splitter.altData = <T extends any[] | undefined = undefined>(
-        ...args: T[]
-    ): GetSetReturn<T, any[], AxisSplitter> => {
+
+    splitter.altData = (...args: any[][]): any => {
         if (!args.length) {
-            return altData as GetSetReturn<T, any[], AxisSplitter>;
+            return altData;
         }
         altData = args[0];
         return splitter;