@hpcc-js/form 2.11.2 → 3.1.0

package/package.json

@@ -1,55 +1,52 @@
 {
     "name": "@hpcc-js/form",
-    "version": "2.11.2",
+    "version": "3.1.0",
     "description": "hpcc-js - Viz Form",
-    "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/chart": "^2.85.0",
-        "@hpcc-js/common": "^2.72.0"
+        "@hpcc-js/api": "^3.2.0",
+        "@hpcc-js/chart": "^3.2.0",
+        "@hpcc-js/common": "^3.2.0"
     },
     "devDependencies": {
-        "@hpcc-js/bundle": "^2.12.0",
+        "@hpcc-js/esbuild-plugins": "^1.3.0",
         "d3-brush": "^1",
         "d3-color": "3.1.0",
         "d3-drag": "^1",
         "d3-scale": "^1",
-        "d3-selection": "^1",
-        "tslib": "2.6.3"
+        "d3-selection": "^1"
     },
     "repository": {
         "type": "git",
@@ -62,5 +59,5 @@
         "url": "https://github.com/hpcc-systems/Visualization/issues"
     },
     "homepage": "https://github.com/hpcc-systems/Visualization",
-    "gitHead": "9e1dd990858b6fb5dd0e46425def23c9609c147a"
+    "gitHead": "658c50fd965a7744ba8db675ba6878607c44d5e2"
 }

package/src/Button.ts

@@ -36,16 +36,17 @@ export class Button extends HTMLWidget {
 
         this._inputElement[0].text(this.value());
     }
-
-    //  IInput  ---
-    name: { (): string; (_: string): Button };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): Button };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): Button };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): Button };
-    validate_exists: () => boolean;
 }
 Button.prototype._class += " form_Button";
 Button.prototype.implements(IInput.prototype);
+
+export interface Button {
+    name(): string;
+    name(_: string): Button;
+    label(): string;
+    label(_: string): Button;
+    value(): any;
+    value(_: any): Button;
+    validate(): string;
+    validate(_: string): Button;
+}

package/src/CheckBox.ts

@@ -75,21 +75,29 @@ export class CheckBox extends HTMLWidget {
         }
         this._inputElement[0].html(optionHTML);
     }
-
-    selectOptions: { (): any[]; (_: any[]): CheckBox };
-    selectOptions_exists: () => boolean;
-
-    //  IInput  ---
-    name: { (): string; (_: string): CheckBox };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): CheckBox };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): CheckBox };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): CheckBox };
-    validate_exists: () => boolean;
 }
 CheckBox.prototype._class += " form_CheckBox";
 CheckBox.prototype.implements(IInput.prototype);
 
+export interface CheckBox {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any;
+    value(_: any): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+
+    //  Properties  ---
+    selectOptions(): any[];
+    selectOptions(_: any[]): this;
+    selectOptions_exists(): boolean;
+}
+
 CheckBox.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");

package/src/ColorInput.ts

@@ -60,16 +60,22 @@ export class ColorInput extends HTMLWidget {
         this._inputElement[1].style("height", (bbox.height - 2) + "px");
 
     }
-
-    //  IInput  ---
-    name: { (): string; (_: string): ColorInput };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): ColorInput };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): ColorInput };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): ColorInput };
-    validate_exists: () => boolean;
 }
 ColorInput.prototype._class += " form_ColorInput";
 ColorInput.prototype.implements(IInput.prototype);
+
+export interface ColorInput {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any;
+    value(_: any): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+}

package/src/FieldForm.ts

@@ -1,6 +1,6 @@
 import { Database } from "@hpcc-js/common";
-import { Form } from "./Form";
-import { Input } from "./Input";
+import { Form } from "./Form.ts";
+import { Input } from "./Input.ts";
 
 import "../src/Form.css";
 

package/src/Form.ts

@@ -1,5 +1,5 @@
 import { d3Event, HTMLWidget, select as d3Select, SVGWidget, Widget, WidgetArray } from "@hpcc-js/common";
-import { Button } from "./Button";
+import { Button } from "./Button.ts";
 
 import "../src/Form.css";
 
@@ -308,21 +308,28 @@ export class Form extends HTMLWidget {
 
     click(row, col, sel) {
     }
-
-    validate: { (): boolean; (_: boolean): Form };
-    validate_exists: () => boolean;
-    inputs: { (): any[]; (_: any[]): Form };
-    inputs_exists: () => boolean;
-    inputs_reset: () => void;
-    showSubmit: { (): boolean; (_: boolean): Form };
-    showSubmit_exists: () => boolean;
-    omitBlank: { (): boolean; (_: boolean): Form };
-    omitBlank_exists: () => boolean;
-    allowEmptyRequest: { (): boolean; (_: boolean): Form };
-    allowEmptyRequest_exists: () => boolean;
 }
 Form.prototype._class += " form_Form";
 
+export interface Form {
+    validate(): boolean;
+    validate(_: boolean): this;
+    validate_exists(): boolean;
+    inputs(): any[];
+    inputs(_: any[]): this;
+    inputs_exists(): boolean;
+    inputs_reset(): void;
+    showSubmit(): boolean;
+    showSubmit(_: boolean): this;
+    showSubmit_exists(): boolean;
+    omitBlank(): boolean;
+    omitBlank(_: boolean): this;
+    omitBlank_exists(): boolean;
+    allowEmptyRequest(): boolean;
+    allowEmptyRequest(_: boolean): this;
+    allowEmptyRequest_exists(): boolean;
+}
+
 Form.prototype.publish("validate", true, "boolean", "Enable/Disable input validation");
 Form.prototype.publish("inputs", [], "widgetArray", "Array of input widgets", null, { render: false });
 Form.prototype.publish("showSubmit", true, "boolean", "Show Submit/Cancel Controls");

package/src/Input.ts

@@ -1,5 +1,5 @@
 import { IInput } from "@hpcc-js/api";
-import { HTMLWidget } from "@hpcc-js/common";
+import { Database, HTMLWidget } from "@hpcc-js/common";
 
 import "../src/Input.css";
 
@@ -90,32 +90,47 @@ export class Input extends HTMLWidget {
         }
     }
 
-    type: { (): string; (_: string): Input };
-    type_exists: () => boolean;
-    type_default: { (): string; (_: string): Input };
-    inlineLabel: { (): string; (_: string): Input };
-    inlineLabel_exists: () => boolean;
-
-    //  IInput  ---
-    name: { (): string; (_: string): Input };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): Input };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): Input };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): Input };
-    validate_exists: () => boolean;
-
     //  IInput Events ---
-    blur: (w: Input) => void;
-    keyup: (w: Input) => void;
-    focus: (w: Input) => void;
-    click: (w: Input) => void;
-    dblclick: (w: Input) => void;
-    change: (w: Input, complete: boolean) => void;
+    blur(w: Input) {
+    }
+    keyup(w: Input) {
+    }
+    focus(w: Input) {
+    }
+    click(w: Input) {
+    }
+    dblclick(w: Input) {
+    }
+    change(w: Input, complete: boolean) {
+    }
 }
 Input.prototype._class += " form_Input";
 Input.prototype.implements(IInput.prototype);
 
-Input.prototype.publish("type", "text", "set", "Input type", ["number", "button", "checkbox", "date", "text", "textarea", "search", "email", "time", "datetime", "hidden"]);
+export interface Input {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any;
+    value(_: any): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+
+    //  Properties  ---
+    type(): Database.FieldType | "button" | "checkbox" | "text" | "textarea" | "search" | "email" | "datetime";
+    type(_: Database.FieldType | "button" | "checkbox" | "text" | "textarea" | "search" | "email" | "datetime"): this;
+    type_exists(): boolean;
+    type_default(): string;
+    inlineLabel(): string;
+    inlineLabel(_: string): this;
+    inlineLabel_exists(): boolean;
+}
+
+Input.prototype.publish("type", "text", "set", "Input type", ["string", "number", "boolean", "date", "time", "hidden", "nested", "button", "checkbox", "text", "textarea", "search", "email", "datetime"]);
 Input.prototype.publish("inlineLabel", null, "string", "Input Label", null, { optional: true });

package/src/InputRange.ts

@@ -62,25 +62,34 @@ export class InputRange extends HTMLWidget {
                 .property("value", this._rangeData.length > idx ? this._rangeData[idx] : "");
         }, this);
     }
-
-    type: { (): string; (_: string): InputRange };
-    type_exists: () => boolean;
-    inlineLabel: { (): string; (_: string): InputRange };
-    inlineLabel_exists: () => boolean;
-    value: { (): any[]; (_: any[]): InputRange };
-    value_exists: () => boolean;
-
-    //  IInput  ---
-    name: { (): string; (_: string): InputRange };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): InputRange };
-    label_exists: () => boolean;
-    validate: { (): string; (_: string): InputRange };
-    validate_exists: () => boolean;
 }
 InputRange.prototype._class += " form_InputRange";
 InputRange.prototype.implements(IInput.prototype);
 
+export interface InputRange {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any[];
+    value(_: any[]): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+
+    //  Properties  ---
+    type(): string;
+    type(_: string): this;
+    type_exists(): boolean;
+    inlineLabel(): string;
+    inlineLabel(_: string): this;
+    inlineLabel_exists(): boolean;
+}
+
 InputRange.prototype.publish("type", "text", "set", "InputRange type", ["number", "date", "text", "time", "datetime", "hidden"]);
 InputRange.prototype.publish("inlineLabel", null, "string", "InputRange Label", null, { optional: true });
 InputRange.prototype.publish("value", ["", ""], "array", "Input Current Value", null, { override: true });

package/src/OnOff.ts

@@ -96,19 +96,24 @@ export class OnOff extends HTMLWidget {
             .style("background-color", this.onColor())
             ;
     }
-
-    //  IInput  ---
-    name: { (): string; (_: string): OnOff };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): OnOff };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): OnOff };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): OnOff };
-    validate_exists: () => boolean;
 }
 OnOff.prototype._class += " form_OnOff";
 export interface OnOff {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any;
+    value(_: any): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+
+    //  Properties  ---
     marginLeft(): number;
     marginLeft(_: number): this;
     marginBottom(): number;

package/src/Radio.ts

@@ -55,21 +55,29 @@ export class Radio extends HTMLWidget {
             }
         });
     }
-
-    selectOptions: { (): any[]; (_: any[]): Radio };
-    selectOptions_exists: () => boolean;
-
-    //  IInput  ---
-    name: { (): string; (_: string): Radio };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): Radio };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): Radio };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): Radio };
-    validate_exists: () => boolean;
 }
 Radio.prototype._class += " form_Radio";
 Radio.prototype.implements(IInput.prototype);
 
+export interface Radio {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any;
+    value(_: any): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+
+    //  Properties  ---
+    selectOptions(): any[];
+    selectOptions(_: any[]): this;
+    selectOptions_exists(): boolean;
+}
+
 Radio.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");

package/src/Range.ts

@@ -72,31 +72,43 @@ export class Range extends HTMLWidget {
         }
         this._inputElement[0].html(optionHTML);
     }
-
-    type: { (): string; (_: string): Range };
-    type_exists: () => boolean;
-    selectOptions: { (): any[]; (_: any[]): Range };
-    selectOptions_exists: () => boolean;
-    low: { (): number; (_: number): Range };
-    low_exists: () => boolean;
-    high: { (): number; (_: number): Range };
-    high_exists: () => boolean;
-    step: { (): number; (_: number): Range };
-    step_exists: () => boolean;
-
-    //  IInput  ---
-    name: { (): string; (_: string): Range };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): Range };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): Range };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): Range };
-    validate_exists: () => boolean;
 }
 Range.prototype._class += " form_Range";
 Range.prototype.implements(IInput.prototype);
 
+export interface Range {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any;
+    value(_: any): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+
+    //  Properties  ---
+    type(): string;
+    type(_: string): this;
+    type_exists(): boolean;
+    selectOptions(): any[];
+    selectOptions(_: any[]): this;
+    selectOptions_exists(): boolean;
+    low(): number;
+    low(_: number): this;
+    low_exists(): boolean;
+    high(): number;
+    high(_: number): this;
+    high_exists(): boolean;
+    step(): number;
+    step(_: number): this;
+    step_exists(): boolean;
+}
+
 Range.prototype.publish("type", "text", "set", "Input type", ["html-color", "number", "checkbox", "button", "select", "textarea", "date", "text", "range", "search", "email", "time", "datetime"]);
 Range.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");
 Range.prototype.publish("low", null, "number", "Minimum value for Range input");

package/src/Select.ts

@@ -57,24 +57,33 @@ export class Select extends HTMLWidget {
         }
         this._inputElement[0].html(optionHTML);
     }
-
-    selectOptions: { (): any[]; (_: any[]): Select };
-    selectOptions_exists: () => boolean;
-    maxWidth: { (): number; (_: number): Select };
-    maxWidth_exists: () => boolean;
-
-    //  IInput  ---
-    name: { (): string; (_: string): Select };
-    name_exists: () => boolean;
-    label: { (): string; (_: string): Select };
-    label_exists: () => boolean;
-    value: { (): any; (_: any): Select };
-    value_exists: () => boolean;
-    validate: { (): string; (_: string): Select };
-    validate_exists: () => boolean;
 }
 Select.prototype._class += " form_Select";
 Select.prototype.implements(IInput.prototype);
 
+export interface Select {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    name_exists(): boolean;
+    label(): string;
+    label(_: string): this;
+    label_exists(): boolean;
+    value(): any;
+    value(_: any): this;
+    value_exists(): boolean;
+    validate(): string;
+    validate(_: string): this;
+    validate_exists(): boolean;
+
+    //  Properties  ---
+    selectOptions(): any[];
+    selectOptions(_: any[]): this;
+    selectOptions_exists(): boolean;
+    maxWidth(): number;
+    maxWidth(_: number): this;
+    maxWidth_exists(): boolean;
+}
+
 Select.prototype.publish("selectOptions", [], "array", "Array of options used to fill a dropdown list");
 Select.prototype.publish("maxWidth", 120, "number", "Width", null, { optional: true });

package/src/Slider.ts

@@ -270,13 +270,17 @@ export class Slider extends SVGWidget {
         return retVal;
     };
 
-    name: (_?: string) => string | this;
-    change: (_: Slider) => void;
 }
 Slider.prototype._class += " form_Slider";
 Slider.prototype.implements(IInput.prototype);
 
 export interface Slider {
+    //  IInput  ---
+    name(): string;
+    name(_: string): this;
+    change(_: Slider): void;
+
+    //  Properties ---
     padding(): number;
     padding(_: number): this;
     fontSize(): number;
@@ -357,7 +361,7 @@ Slider.prototype.publish("tickDateFormat", null, "string");
 Slider.prototype.publish("tickValueFormat", ",.0f", "string");
 
 const name = Slider.prototype.name;
-Slider.prototype.name = function (_: any): any {
+Slider.prototype.name = function (_?: any): any {
     const retVal = name.apply(this, arguments);
     if (arguments.length) {
         const val = _ instanceof Array ? _ : [_];

package/src/TextArea.ts

@@ -1,4 +1,4 @@
-import { Input } from "./Input";
+import { Input } from "./Input.ts";
 
 export class TextArea extends Input {
     constructor() {
@@ -27,20 +27,27 @@ export class TextArea extends Input {
             ;
     }
 
-    rows: { (): number; (_: number): TextArea };
-    rows_exists: () => boolean;
-    cols: { (): number; (_: number): TextArea };
-    cols_exists: () => boolean;
-    wrap: { (): string; (_: string): TextArea };
-    wrap_exists: () => boolean;
-    minHeight: { (): number; (_: number): TextArea };
-    minHeight_exists: () => boolean;
-    spellcheck: { (): boolean; (_: boolean): TextArea };
-    spellcheck_exists: () => boolean;
-    value: { (): any; (_: any): TextArea };
 }
 TextArea.prototype._class += " form_TextArea";
 
+export interface TextArea {
+    rows(): number;
+    rows(_: number): this;
+    rows_exists(): boolean;
+    cols(): number;
+    cols(_: number): this;
+    cols_exists(): boolean;
+    wrap(): string;
+    wrap(_: string): this;
+    wrap_exists(): boolean;
+    minHeight(): number;
+    minHeight(_: number): this;
+    minHeight_exists(): boolean;
+    spellcheck(): boolean;
+    spellcheck(_: boolean): this;
+    spellcheck_exists(): boolean;
+}
+
 TextArea.prototype.publish("rows", null, "number", "Rows", null, { optional: true });
 TextArea.prototype.publish("cols", null, "number", "Columns", null, { optional: true });
 TextArea.prototype.publish("wrap", "off", "set", "Wrap", ["off", "on"]);

package/src/__package__.ts

@@ -1,3 +1,3 @@
 export const PKG_NAME = "@hpcc-js/form";
-export const PKG_VERSION = "2.11.2";
-export const BUILD_VERSION = "2.106.4";
+export const PKG_VERSION = "3.1.0";
+export const BUILD_VERSION = "3.2.0";