@hpcc-js/other 2.16.2 → 3.1.0

package/package.json

@@ -1,49 +1,47 @@
 {
     "name": "@hpcc-js/other",
-    "version": "2.16.2",
+    "version": "3.1.0",
     "description": "hpcc-js - Viz Other",
-    "main": "dist/index.js",
-    "module": "dist/index.es6",
-    "unpkg": "dist/index.min.js",
-    "jsdelivr": "dist/index.min.js",
-    "types": "types/index.d.ts",
-    "typesVersions": {
-        "<3.8": {
-            "*": [
-                "types-3.4/index.d.ts"
-            ]
-        }
+    "type": "module",
+    "exports": {
+        ".": {
+            "types": "./types/index.d.ts",
+            "default": "./dist/index.js"
+        },
+        "./dist/*": "./dist/*"
     },
+    "module": "./dist/index.js",
+    "browser": "./dist/index.js",
+    "types": "./types/index.d.ts",
     "files": [
         "dist/*",
+        "src/*",
         "types/*",
-        "types-3.4/*",
-        "src/*"
+        "font-awesome/**/*"
     ],
     "scripts": {
-        "clean": "rimraf --glob lib* types dist *.tsbuildinfo",
-        "compile-es6": "tsc --module es6 --outDir ./lib-es6",
-        "compile-es6-watch": "npm run compile-es6 -- -w",
-        "compile-umd": "tsc --module umd --outDir ./lib-umd",
-        "compile-umd-watch": "npm run compile-umd -- -w",
-        "bundle": "rollup -c",
-        "bundle-watch": "npm run bundle -- -w",
-        "minimize": "terser dist/index.js -c -m --source-map \"content='dist/index.js.map',url='index.min.js.map'\" -o dist/index.min.js",
-        "gen-legacy-types": "downlevel-dts ./types ./types-3.4",
-        "build": "npm run compile-es6 && npm run bundle",
-        "watch": "npm-run-all compile-es6 -p compile-es6-watch bundle-watch",
-        "stamp": "node ../../node_modules/@hpcc-js/bundle/src/stamp.js",
+        "clean": "rimraf --glob lib* types dist *.tsbuildinfo .turbo",
+        "bundle": "node esbuild.js",
+        "bundle-watch": "npm run bundle -- --development --watch",
+        "gen-types": "tsc --project tsconfig.json",
+        "gen-types-watch": "npm run gen-types -- --watch",
+        "build": "run-p gen-types bundle",
         "lint": "eslint ./src",
+        "lint-fix": "eslint --fix src/**/*.ts",
         "docs": "typedoc --options tdoptions.json .",
-        "update": "npx --yes npm-check-updates -u -t minor"
+        "test-browser": "vitest run --project browser",
+        "test": "vitest run",
+        "coverage": "vitest run --coverage",
+        "update": "npx --yes npm-check-updates -u -t minor",
+        "update-major": "npx --yes npm-check-updates -u"
     },
     "dependencies": {
-        "@hpcc-js/api": "^2.13.0",
-        "@hpcc-js/common": "^2.72.0",
-        "@hpcc-js/layout": "^2.50.2"
+        "@hpcc-js/api": "^3.2.0",
+        "@hpcc-js/common": "^3.2.0",
+        "@hpcc-js/layout": "^3.1.0"
     },
     "devDependencies": {
-        "@hpcc-js/bundle": "^2.12.0",
+        "@hpcc-js/esbuild-plugins": "^1.3.0",
         "d3-array": "^1",
         "d3-collection": "^1",
         "d3-format": "^1",
@@ -55,8 +53,7 @@
         "d3-timer": "^1",
         "d3-zoom": "^1",
         "javascript-autocomplete": "1.0.5",
-        "simpleheat": "0.4.0",
-        "tslib": "2.6.3"
+        "simpleheat": "0.4.0"
     },
     "repository": {
         "type": "git",
@@ -69,5 +66,5 @@
         "url": "https://github.com/hpcc-systems/Visualization/issues"
     },
     "homepage": "https://github.com/hpcc-systems/Visualization",
-    "gitHead": "9e1dd990858b6fb5dd0e46425def23c9609c147a"
+    "gitHead": "658c50fd965a7744ba8db675ba6878607c44d5e2"
 }

package/src/Audio.ts

@@ -74,10 +74,13 @@ export class Audio extends HTMLWidget {
         });
         this.node().load();
     }
-
-    source: { (): string; (_: string): Audio };
-    source_exists: () => boolean;
 }
 Audio.prototype._class += " other_Audio";
 
+export interface Audio {
+    source(): string;
+    source(_: string): this;
+    source_exists(): boolean;
+}
+
 Audio.prototype.publish("source", "", "string", "Audio Source");

package/src/AutoCompleteText.ts

@@ -1,5 +1,5 @@
 import { HTMLWidget } from "@hpcc-js/common";
-import * as AutoComplete from "javascript-autocomplete";
+import AutoComplete from "javascript-autocomplete";
 
 import "../src/AutoCompleteText.css";
 
@@ -100,22 +100,30 @@ export class AutoCompleteText extends HTMLWidget {
 
     click(row, column, selected) {
     }
-
-    label: { (): string; (_: string): AutoCompleteText };
-    label_exists: () => boolean;
-    textboxWidth: { (): number; (_: number): AutoCompleteText };
-    textboxWidth_exists: () => boolean;
-    placeholder: { (): string; (_: string): AutoCompleteText };
-    placeholder_exists: () => boolean;
-    valueColumn: { (): string; (_: string): AutoCompleteText };
-    valueColumn_exists: () => boolean;
-    textColumn: { (): string; (_: string): AutoCompleteText };
-    textColumn_exists: () => boolean;
-    minCharsText: { (): number; (_: number): AutoCompleteText };
-    minCharsText_exists: () => boolean;
 }
 AutoCompleteText.prototype._class += " other_AutoCompleteText";
 
+export interface AutoCompleteText {
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    textboxWidth(): number;
+    textboxWidth(_: number): this;
+    textboxWidth_exists(): boolean;
+    placeholder(): string;
+    placeholder(_: string): this;
+    placeholder_exists(): boolean;
+    valueColumn(): string;
+    valueColumn(_: string): this;
+    valueColumn_exists(): boolean;
+    textColumn(): string;
+    textColumn(_: string): this;
+    textColumn_exists(): boolean;
+    minCharsText(): number;
+    minCharsText(_: number): this;
+    minCharsText_exists(): boolean;
+}
+
 AutoCompleteText.prototype.publish("label", "Label: ", "string", "Label for AutoCompleteText");
 AutoCompleteText.prototype.publish("textboxWidth", null, "number", "width of textbox", null, { optional: true });
 AutoCompleteText.prototype.publish("placeholder", "Search...", "string", "Placeholder for AutoCompleteText");

package/src/CalendarHeatMap.ts

@@ -199,29 +199,24 @@ export class CalendarHeatMap extends HTMLWidget {
 
     dblclick(row, column, selected) {
     }
-
-    _palette;
-    paletteID: { (): string; (_: string): CalendarHeatMap };
-    paletteID_exists: () => boolean;
-    dateColumn: { (): string; (_: string): CalendarHeatMap };
-    dateColumn_exists: () => boolean;
-    datePattern: { (): string; (_: string): CalendarHeatMap };
-    datePattern_exists: () => boolean;
-    aggrType: { (): string; (_: string): CalendarHeatMap };
-    aggrType_exists: () => boolean;
-    aggrColumn: { (): string; (_: string): CalendarHeatMap };
-    aggrColumn_exists: () => boolean;
-    aggrDeltaColumn: { (): string; (_: string): CalendarHeatMap };
-    aggrDeltaColumn_exists: () => boolean;
-
-    //  SimpleSelectionMixin
-    _selection;
 }
 CalendarHeatMap.prototype._class += " other_CalendarHeatMap";
 CalendarHeatMap.prototype.mixin(Utility.SimpleSelectionMixin);
 CalendarHeatMap.prototype._palette = Palette.rainbow("default");
 
 export interface CalendarHeatMap {
+    _palette;
+
+    // SimpleSelectionMixin  ---
+    _selection
+
+    //  Properties  ---
+    paletteID(): string;
+    paletteID(_: string): this;
+    paletteID_exists(): boolean;
+    datePattern(): string;
+    datePattern(_: string): this;
+    datePattern_exists(): boolean;
     dayStrokeColor(): string;
     dayStrokeColor(_: string): this;
     monthStrokeColor(): string;
@@ -230,6 +225,18 @@ export interface CalendarHeatMap {
     dayStrokeWidth(_: number): this;
     monthStrokeWidth(): number;
     monthStrokeWidth(_: number): this;
+    dateColumn(): string;
+    dateColumn(_: string): this;
+    dateColumn_exists(): boolean;
+    aggrType(): string;
+    aggrType(_: string): this;
+    aggrType_exists(): boolean;
+    aggrColumn(): string;
+    aggrColumn(_: string): this;
+    aggrColumn_exists(): boolean;
+    aggrDeltaColumn(): string;
+    aggrDeltaColumn(_: string): this;
+    aggrDeltaColumn_exists(): boolean;
 }
 CalendarHeatMap.prototype.publish("paletteID", "YlOrRd", "set", "Color palette for this widget", CalendarHeatMap.prototype._palette.switch(), { tags: ["Basic", "Shared"] });
 CalendarHeatMap.prototype.publish("dayStrokeColor", "#ccc", "html-color", "Color of day border");

package/src/ESP.ts

@@ -1,5 +1,5 @@
 import { Utility } from "@hpcc-js/common";
-import * as Comms from "./Comms";
+import * as Comms from "./Comms.ts";
 
 function nestedRowFix(row) {
     if (row.Row && row.Row instanceof Array) {

package/src/HeatMap.ts

@@ -5,7 +5,6 @@ const simpleheat = (window as any).simpleheat || (_simpleheat && _simpleheat.def
 
 export class HeatMap extends CanvasWidget {
     _heat;
-    _palette;
 
     constructor() {
         super();
@@ -88,35 +87,51 @@ export class HeatMap extends CanvasWidget {
 
         return retArr;
     }
-
-    radius: { (): number; (_: number): HeatMap };
-    radius_exists: () => boolean;
-    blur: { (): number; (_: number): HeatMap };
-    blur_exists: () => boolean;
-    max: { (): number; (_: number): HeatMap };
-    max_exists: () => boolean;
-    gradient: { (): object; (_: object): HeatMap };
-    gradient_exists: () => boolean;
-    usePalette: { (): boolean; (_: boolean): HeatMap };
-    usePalette_exists: () => boolean;
-    colorCount: { (): number; (_: number): HeatMap };
-    colorCount_exists: () => boolean;
-    paletteID: { (): string; (_: string): HeatMap };
-    paletteID_exists: () => boolean;
-    useClonedPalette: { (): boolean; (_: boolean): HeatMap };
-    useClonedPalette_exists: () => boolean;
-    topLeftX: { (): number; (_: number): HeatMap };
-    topLeftX_exists: () => boolean;
-    topLeftY: { (): number; (_: number): HeatMap };
-    topLeftY_exists: () => boolean;
-    bottomRightX: { (): number; (_: number): HeatMap };
-    bottomRightX_exists: () => boolean;
-    bottomRightY: { (): number; (_: number): HeatMap };
-    bottomRightY_exists: () => boolean;
 }
 HeatMap.prototype._class += " other_HeatMap";
 HeatMap.prototype._palette = Palette.rainbow("default");
 
+export interface HeatMap {
+    _palette;
+
+    radius(): number;
+    radius(_: number): this;
+    radius_exists(): boolean;
+    blur(): number;
+    blur(_: number): this;
+    blur_exists(): boolean;
+    max(): number;
+    max(_: number): this;
+    max_exists(): boolean;
+    gradient(): object;
+    gradient(_: object): this;
+    gradient_exists(): boolean;
+    usePalette(): boolean;
+    usePalette(_: boolean): this;
+    usePalette_exists(): boolean;
+    colorCount(): number;
+    colorCount(_: number): this;
+    colorCount_exists(): boolean;
+    paletteID(): string;
+    paletteID(_: string): this;
+    paletteID_exists(): boolean;
+    useClonedPalette(): boolean;
+    useClonedPalette(_: boolean): this;
+    useClonedPalette_exists(): boolean;
+    topLeftX(): number;
+    topLeftX(_: number): this;
+    topLeftX_exists(): boolean;
+    topLeftY(): number;
+    topLeftY(_: number): this;
+    topLeftY_exists(): boolean;
+    bottomRightX(): number;
+    bottomRightX(_: number): this;
+    bottomRightX_exists(): boolean;
+    bottomRightY(): number;
+    bottomRightY(_: number): this;
+    bottomRightY_exists(): boolean;
+}
+
 HeatMap.prototype.publish("radius", 15, "number", "Set point radius", null, { tags: ["Basic"] });
 HeatMap.prototype.publish("blur", 15, "number", "Set point blur", null, { tags: ["Basic"] });
 HeatMap.prototype.publish("max", 1, "number", "Set max data value", null, { tags: ["Basic"] });

package/src/Html.ts

@@ -29,16 +29,20 @@ export class Html extends HTMLWidget {
             ;
         html.exit().remove();
     }
-
-    html: { (): string; (_: string): Html };
-    html_exists: () => boolean;
-    overflowX: { (): string; (_: string): Html };
-    overflowX_exists: () => boolean;
-    overflowY: { (): string; (_: string): Html };
-    overflowY_exists: () => boolean;
 }
 Html.prototype._class += " other_Html";
 
+export interface Html {
+    html(): string;
+    html(_: string): Html;
+    overflowX(): string;
+    overflowX(_: string): Html;
+    overflowX_exists(): boolean;
+    overflowY(): string;
+    overflowY(_: string): Html;
+    overflowY_exists(): boolean;
+}
+
 Html.prototype.publish("html", "", "string", "Html to render", null, { tags: ["Basic"] });
 Html.prototype.publish("overflowX", null, "set", "CSS overflow-x", ["", "visible", "hidden", "scroll", "auto", "initial", "inherit"], { tags: ["Basic"], optional: true });
 Html.prototype.publish("overflowY", null, "set", "CSS overflow-y", ["", "visible", "hidden", "scroll", "auto", "initial", "inherit"], { tags: ["Basic"], optional: true });

package/src/IconList.ts

@@ -1,7 +1,7 @@
 import { Entity, HTMLWidget } from "@hpcc-js/common";
 import { HorizontalList, VerticalList } from "@hpcc-js/layout";
 import { select as d3Select } from "d3-selection";
-import { Html } from "./Html";
+import { Html } from "./Html.ts";
 
 import "../src/IconList.css";
 

package/src/Legend.ts

@@ -1,7 +1,7 @@
 import { Palette, Platform } from "@hpcc-js/common";
 import { format as d3Format } from "d3-format";
 import { select as d3Select } from "d3-selection";
-import { Table } from "./Table";
+import { Table } from "./Table.ts";
 
 import "../src/Legend.css";
 
@@ -185,17 +185,24 @@ export class Legend extends Table {
     onMouseOver(rowData, rowIdx) {
     }
 
-    dataFamily: { (): string; (_: string): Legend };
-    dataFamily_exists: () => boolean;
-    orientation: { (): string; (_: string): Legend };
-    orientation_exists: () => boolean;
-    rainbowFormat: { (): string; (_: string): Legend };
-    rainbowFormat_exists: () => boolean;
-    rainbowBins: { (): number; (_: number): Legend };
-    rainbowBins_exists: () => boolean;
 }
 Legend.prototype._class += " other_Legend";
 
+export interface Legend {
+    dataFamily(): string;
+    dataFamily(_: string): this;
+    dataFamily_exists(): boolean;
+    orientation(): string;
+    orientation(_: string): this;
+    orientation_exists(): boolean;
+    rainbowFormat(): string;
+    rainbowFormat(_: string): this;
+    rainbowFormat_exists(): boolean;
+    rainbowBins(): number;
+    rainbowBins(_: number): this;
+    rainbowBins_exists(): boolean;
+}
+
 Legend.prototype.publish("dataFamily", "ND", "set", "Type of data", ["1D", "2D", "ND", "map", "any", "other"], { tags: ["Private"] });
 Legend.prototype.publish("orientation", "vertical", "set", "Orientation of Legend rows", ["vertical", "horizontal"], { tags: ["Private"] });
 Legend.prototype.publish("rainbowFormat", ",", "string", "Rainbow number formatting", null, { tags: ["Private"], optional: true, disable: w => !w.isRainbow() });

package/src/MorphText.ts

@@ -67,24 +67,31 @@ export class MorphText extends SVGWidget {
             .remove()
             ;
     }
-    anchor: { (): string; (_: string): MorphText };
-    anchor_exists: () => boolean;
-    fontSize: { (): number; (_: number): MorphText };
-    fontSize_exists: () => boolean;
-    reverse: { (): boolean; (_: boolean): MorphText };
-    reverse_exists: () => boolean;
-    text: (_?: string) => MorphText | this;
-    text_exists: () => boolean;
 }
 MorphText.prototype._class += " other_MorphText";
 
+export interface MorphText {
+    anchor(): string;
+    anchor(_: string): this;
+    anchor_exists(): boolean;
+    fontSize(): number;
+    fontSize(_: number): this;
+    fontSize_exists(): boolean;
+    reverse(): boolean;
+    reverse(_: boolean): this;
+    reverse_exists(): boolean;
+    text(): string;
+    text(_: string): this;
+    text_exists(): boolean;
+}
+
 MorphText.prototype.publish("anchor", "middle", "set", "Sets anchor point", ["middle"], { tags: ["Basic"] });
 MorphText.prototype.publish("fontSize", 14, "number", "Sets fontsize", null, { tags: ["Basic"] });
 MorphText.prototype.publish("reverse", false, "boolean", "Reverse Animation", null, { tags: ["Basic"] });
 MorphText.prototype.publish("text", "", "string", "Sets text/data of widget", null, { tags: ["Basic"] });
 
 const _origText = MorphText.prototype.text;
-MorphText.prototype.text = function (_) {
+MorphText.prototype.text = function (_?: string) {
     const retVal = _origText.apply(this, arguments);
     if (arguments.length) {
         const usedChars = {};

package/src/NestedTable.ts

@@ -1,4 +1,4 @@
-import { Table } from "./Table";
+import { Table } from "./Table.ts";
 
 export class NestedTable extends Table {
     constructor() {

package/src/Opportunity.ts

@@ -424,32 +424,44 @@ export class Opportunity extends SVGWidget {
         dropdownList.unshift("default");
         return dropdownList;
     }
-    previousGroup: { (): string; (_: string): Opportunity };
-    previousGroup_exists: () => boolean;
-    currentGroup: { (): string; (_: string): Opportunity };
-    currentGroup_exists: () => boolean;
-    opportunityId: { (): string; (_: string): Opportunity };
-    opportunityId_exists: () => boolean;
-    url: { (): string; (_: string): Opportunity };
-    url_exists: () => boolean;
-    // width: { (): number; (_: number): Opportunity };
-    width_exists: () => boolean;
-    addColumn: { (): string; (_: string): Opportunity };
-    addColumn_exists: () => boolean;
-    removeColumn: { (): string; (_: string): Opportunity };
-    removeColumn_exists: () => boolean;
-    headerLabels: { (): any[]; (_: any[]): Opportunity };
-    headerLabels_exists: () => boolean;
-    mouseHover: { (): any[]; (_: any[]): Opportunity };
-    mouseHover_exists: () => boolean;
-    columnData: { (): any[]; (_: any[]): Opportunity };
-    columnData_exists: () => boolean;
 }
 Opportunity.prototype._class += " other_Opportunity";
 Opportunity.prototype.Column = Column;
 Opportunity.prototype.MouseHoverColumn = MouseHoverColumn;
 Opportunity.prototype.ColumnDropdown = ColumnDropdown;
 
+export interface Opportunity {
+    previousGroup(): string;
+    previousGroup(_: string): this;
+    previousGroup_exists(): boolean;
+    currentGroup(): string;
+    currentGroup(_: string): this;
+    currentGroup_exists(): boolean;
+    opportunityId(): string;
+    opportunityId(_: string): this;
+    opportunityId_exists(): boolean
+    url(): string;
+    url(_: string): this;
+    url_exists(): boolean;
+    // width(): number;
+    // width(_: number): this;
+    addColumn(): string;
+    addColumn(_: string): this;
+    addColumn_exists(): boolean;
+    removeColumn(): string;
+    removeColumn(_: string): this;
+    removeColumn_exists(): boolean;
+    headerLabels(): any[];
+    headerLabels(_: any[]): this;
+    headerLabels_exists(): boolean;
+    mouseHover(): any[];
+    mouseHover(_: any[]): this;
+    mouseHover_exists(): boolean;
+    columnData(): any[];
+    columnData(_: any[]): this;
+    columnData_exists(): boolean;
+}
+
 Opportunity.prototype.publish("previousGroup", "", "set", "label in Opportunity", function () { return this.getIds(); }, { tags: ["Basic", "Shared"] });
 Opportunity.prototype.publish("currentGroup", "", "set", "label in Opportunity", function () { return this.getIds(); }, { tags: ["Basic", "Shared"] });
 Opportunity.prototype.publish("opportunityId", "id", "set", "Id for label in Opportunity", function () { return this.getIds(); }, { tags: ["Basic", "Shared"] });

package/src/Paginator.ts

@@ -139,22 +139,30 @@ export class Paginator extends HTMLWidget {
     exit(domNode, element) {
         super.exit(domNode, element);
     }
-
-    itemsPerPage: { (): number; (_: number): Paginator };
-    itemsPerPage_exists: () => boolean;
-    numItems: { (): number; (_: number): Paginator };
-    numItems_exists: () => boolean;
-    pageNumber: { (): number; (_: number): Paginator };
-    pageNumber_exists: () => boolean;
-    adjacentPages: { (): number; (_: number): Paginator };
-    adjacentPages_exists: () => boolean;
-    bottom: { (): number; (_: number): Paginator };
-    bottom_exists: () => boolean;
-    right: { (): number; (_: number): Paginator };
-    right_exists: () => boolean;
 }
 Paginator.prototype._class += " other_Paginator";
 
+export interface Paginator {
+    itemsPerPage(): number;
+    itemsPerPage(_: number): this;
+    itemsPerPage_exists(): boolean;
+    numItems(): number;
+    numItems(_: number): this;
+    numItems_exists(): boolean;
+    pageNumber(): number;
+    pageNumber(_: number): this;
+    pageNumber_exists(): boolean;
+    adjacentPages(): number;
+    adjacentPages(_: number): this;
+    adjacentPages_exists(): boolean
+    bottom(): number;
+    bottom(_: number): this;
+    bottom_exists(): boolean;
+    right(): number;
+    right(_: number): this;
+    right_exists(): boolean;
+}
+
 Paginator.prototype.publish("itemsPerPage", 2, "number", "Pagination items per page", null, { tags: ["Private"] });
 
 Paginator.prototype.publish("numItems", 10, "number", "Pagination total number of items", null, { tags: ["Private"] });

package/src/PropertyEditor.ts

@@ -1,7 +1,7 @@
 import { HTMLWidget, Platform, PropertyExt, Widget } from "@hpcc-js/common";
 import { Grid } from "@hpcc-js/layout";
 import { local as d3Local, select as d3Select, selectAll as d3SelectAll } from "d3-selection";
-import * as Persist from "./Persist";
+import * as Persist from "./Persist.ts";
 
 import "../src/PropertyEditor.css";
 
@@ -700,24 +700,36 @@ export class PropertyEditor extends HTMLWidget {
                 break;
         }
     }
-
-    showFields: { (): boolean; (_: boolean): PropertyEditor; };
-    showData: { (): boolean; (_: boolean): PropertyEditor; };
-
-    sorting: { (): string; (_: string): PropertyEditor; };
-    sorting_options: () => string[];
-
-    hideNonWidgets: { (): boolean; (_: boolean): PropertyEditor; };
-
-    label: { (): string; (_: string): PropertyEditor; };
-    filterTags: { (): string; (_: string): PropertyEditor; };
-    excludeTags: { (): string[]; (_: string[]): PropertyEditor; };
-    excludeParams: { (): string[]; (_: string[]): PropertyEditor; };
-
-    widget: { (): PropertyExt; (_: PropertyExt): PropertyEditor };
 }
 PropertyEditor.prototype._class += " other_PropertyEditor";
 
+export interface PropertyEditor {
+    showFields(): boolean;
+    showFields(_: boolean): this;
+    showData(): boolean;
+    showData(_: boolean): this;
+
+    sorting(): string;
+    sorting(_: string): this;
+    sorting_options(): string[];
+    sorting_options(_: string[]): this;
+
+    hideNonWidgets(): boolean;
+    hideNonWidgets(_: boolean): this;
+
+    label(): string;
+    label(_: string): this;
+    filterTags(): string;
+    filterTags(_: string): this;
+    excludeTags(): string[];
+    excludeTags(_: string[]): this;
+    excludeParams(): string[];
+    excludeParams(_: string[]): this;
+
+    widget(): PropertyExt;
+    widget(_: PropertyExt): this;
+}
+
 PropertyEditor.prototype.publish("showFields", false, "boolean", "If true, widget.fields() will display as if it was a publish parameter.", null, { tags: ["Basic"] });
 PropertyEditor.prototype.publish("showData", false, "boolean", "If true, widget.data() will display as if it was a publish parameter.", null, { tags: ["Basic"] });
 

package/src/RadioCheckbox.ts

@@ -102,20 +102,27 @@ export class RadioCheckbox extends HTMLWidget {
 
     click(row, column, selected) {
     }
-
-    label: { (): string; (_: string): RadioCheckbox };
-    label_exists: () => boolean;
-    valueColumn: { (): string; (_: string): RadioCheckbox };
-    valueColumn_exists: () => boolean;
-    textColumn: { (): string; (_: string): RadioCheckbox };
-    textColumn_exists: () => boolean;
-    sort: { (): string; (_: string): RadioCheckbox };
-    sort_exists: () => boolean;
-    multiple: { (): boolean; (_: boolean): RadioCheckbox };
-    multiple_exists: () => boolean;
 }
 RadioCheckbox.prototype._class += " other_RadioCheckbox";
 
+export interface RadioCheckbox {
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    valueColumn(): string;
+    valueColumn(_: string): this;
+    valueColumn_exists(): boolean;
+    textColumn(): string;
+    textColumn(_: string): this;
+    textColumn_exists(): boolean;
+    sort(): string;
+    sort(_: string): this;
+    sort_exists
+    multiple(): boolean;
+    multiple(_: boolean): this;
+    multiple_exists(): boolean;
+}
+
 RadioCheckbox.prototype.publish("label", null, "string", "Label for RadioCheckbox");
 RadioCheckbox.prototype.publish("valueColumn", null, "set", "RadioCheckbox display value", function () { return this.columns(); }, { optional: true });
 RadioCheckbox.prototype.publish("textColumn", null, "set", "RadioCheckbox value(s)", function () { return this.columns(); }, { optional: true });