@pinnacle0/web-ui 0.3.22 → 0.3.23

package/test/ui-test/tsconfig.json

@@ -0,0 +1,3 @@
+{
+    "extends": "../../config/tsconfig.test.json"
+}

package/test/unit-test/ClassNames.test.ts

@@ -0,0 +1,17 @@
+import {classNames} from "../../src/util/ClassNames";
+
+describe("classNames testing", () => {
+    test("basic usage", () => {
+        let extraClass: string | boolean | undefined = undefined;
+        expect(classNames("game-class", {extraClass})).toBe("game-class");
+
+        extraClass = "extra-class-with-longer-name";
+        expect(classNames("game-class", {extraClass})).toBe("game-class extraClass");
+        expect(classNames("game-class", extraClass)).toBe("game-class extra-class-with-longer-name");
+        expect(classNames("game-class", {[extraClass]: extraClass})).toBe("game-class extra-class-with-longer-name");
+        expect(classNames("game-class", extraClass ? "short-class-name" : extraClass)).toBe("game-class short-class-name");
+
+        extraClass = true;
+        expect(classNames("game-class", {extraClass})).toBe("game-class extraClass");
+    });
+});

package/test/unit-test/ExpirableLocalStorageUtil.test.ts

@@ -0,0 +1,42 @@
+import {ExpirableLocalStorageUtil} from "@pinnacle0/web-ui/util/ExpirableLocalStorageUtil";
+
+describe("ExpirableLocalStorageUtil", () => {
+    [
+        ["Bool", true, false],
+        ["String", "abc", ""],
+        ["Number", 123, 0],
+    ].forEach(([type, value, defaultValue]) => {
+        test(type as string, () => {
+            const currentTimestamp = new Date().getTime();
+            const nonExpiredTimestamp = currentTimestamp + 1000;
+            const expiredTimestamp = currentTimestamp - 10;
+
+            ExpirableLocalStorageUtil[`set${type}`](type, value, nonExpiredTimestamp);
+            expect(Object.keys(localStorage).includes(`@@EXPIRABLE/${type}`)).toEqual(true);
+            expect(ExpirableLocalStorageUtil[`get${type}`](type, defaultValue)).toEqual(value);
+
+            ExpirableLocalStorageUtil[`set${type}`](type, value, expiredTimestamp);
+            expect(ExpirableLocalStorageUtil[`get${type}`](type, defaultValue)).toEqual(defaultValue);
+
+            // pruned key because the new expiredTimestamp is expired
+            expect(Object.keys(localStorage).includes(`@@EXPIRABLE/${type}`)).toEqual(false);
+        });
+    });
+
+    test("Object", () => {
+        const currentTimestamp = new Date().getTime();
+        const nonExpiredTimestamp = currentTimestamp + 1000;
+        const expiredTimestamp = currentTimestamp - 10;
+
+        ExpirableLocalStorageUtil.setObject("Object", {a: 1}, nonExpiredTimestamp);
+
+        expect(Object.keys(localStorage).includes("@@EXPIRABLE/Object")).toEqual(true);
+        expect(ExpirableLocalStorageUtil.getObject("Object", {b: 2}, () => true)).toEqual({a: 1});
+
+        ExpirableLocalStorageUtil.setObject("Object", {a: 1}, expiredTimestamp);
+        expect(ExpirableLocalStorageUtil.getObject("Object", {b: 2}, () => true)).toEqual({b: 2});
+
+        // pruned key because the new expiredTimestamp is expired
+        expect(Object.keys(localStorage).includes("@@EXPIRABLE/Object")).toEqual(false);
+    });
+});

package/test/unit-test/NumberInput.util.test.ts

@@ -0,0 +1,344 @@
+import {canAdd, canMinus, clamp, getDisplayValue, rectifyInputIfValid, truncate} from "@pinnacle0/web-ui/core/NumberInput/util";
+
+describe("truncate", () => {
+    const sum = 0.1 + 0.2;
+    const difference = 0.3 - 0.2;
+
+    test("sum and difference fixture has unwanted decimal points", () => {
+        expect(sum.toString()).not.toBe("0.3"); // This should be something like "0.30000000000000004"
+        expect(/\.[0-9]{1}$/.test(sum.toString())).toBe(false);
+
+        expect(difference.toString()).not.toBe("0.1"); // This should be something like "0.09999999999999998"
+        expect(/\.[0-9]{1}$/.test(difference.toString())).toBe(false);
+    });
+
+    test("returns correct number of decimal points after calling truncate()", () => {
+        expect(truncate(sum, 1).toString()).toBe("0.3");
+        expect(truncate(sum, 4).toString()).toBe("0.3");
+
+        expect(truncate(difference, 1).toString()).toBe("0.1");
+        expect(truncate(difference, 4).toString()).toBe("0.1");
+    });
+});
+
+describe("clamp", () => {
+    type Params = Parameters<typeof clamp>[0];
+
+    test("returns min if outside range(min)", () => {
+        const test1: Params = {value: 10, min: 100, max: 200};
+        expect(clamp(test1)).toBe(test1.min);
+        const test2: Params = {value: 0.3 - 0.2, min: 0.1, max: 200};
+        expect(clamp(test2)).toBe(test2.min);
+    });
+
+    test("returns max if outside range(max)", () => {
+        const test1: Params = {value: 1000, min: 100, max: 200};
+        expect(clamp(test1)).toBe(test1.max);
+        const test2: Params = {value: 0.1 + 0.2, min: 0, max: 0.3};
+        expect(clamp(test2)).toBe(test2.max);
+    });
+
+    test("returns original value if within range", () => {
+        const test1: Params = {value: 150, min: 100, max: 200};
+        expect(clamp(test1)).toBe(test1.value);
+        const test2: Params = {value: 0.1 + 0.2, min: 0, max: 1};
+        expect(clamp(test2)).toBe(test2.value);
+        expect(/[0-9]\.[0-9]/.test(clamp(test2).toString())).toBe(true);
+    });
+});
+
+describe("canAdd", () => {
+    type Params = Parameters<typeof canAdd>[0];
+
+    test("allows add if value is null (no value provided)", () => {
+        const props: Params = {
+            value: null,
+            step: null as unknown as number, // don't care
+            max: null as unknown as number, // don't care
+            scale: null as unknown as number, // don't care
+        };
+        expect(canAdd(props)).toBe(true);
+    });
+
+    test("allows add if next value inside range(max)", () => {
+        const integerProps: Params = {
+            value: 9,
+            step: 1,
+            max: 10,
+            scale: 0,
+        };
+        expect(canAdd(integerProps)).toBe(true);
+
+        const floatProps: Params = {
+            value: 0.2,
+            step: 0.1,
+            max: 0.3,
+            scale: 1,
+        };
+        expect(canAdd(floatProps)).toBe(true);
+    });
+
+    test("disallows add if next value outside range(max)", () => {
+        const integerProps: Params = {
+            value: 9,
+            step: 3,
+            max: 10,
+            scale: 0,
+        };
+        expect(canAdd(integerProps)).toBe(false);
+
+        const floatProps: Params = {
+            value: 0.2,
+            step: 0.2,
+            max: 0.3,
+            scale: 1,
+        };
+        expect(canAdd(floatProps)).toBe(false);
+    });
+});
+
+describe("canMinus", () => {
+    type Params = Parameters<typeof canMinus>[0];
+
+    test("allows minus if value is null (no value provided)", () => {
+        const props: Params = {
+            value: null,
+            step: null as unknown as number, // don't care
+            min: null as unknown as number, // don't care
+            scale: null as unknown as number, // don't care
+        };
+        expect(canMinus(props)).toBe(true);
+    });
+
+    test("allows minus if prev value inside range(min)", () => {
+        const integerProps: Params = {
+            value: 1,
+            step: 1,
+            min: 0,
+            scale: 0,
+        };
+        expect(canMinus(integerProps)).toBe(true);
+
+        const floatProps: Params = {
+            value: 0.3,
+            step: 0.2,
+            min: 0.1,
+            scale: 1,
+        };
+        expect(canMinus(floatProps)).toBe(true);
+    });
+
+    test("disallows minus if prev value outside range(min)", () => {
+        const integerProps: Params = {
+            value: 15,
+            step: 10,
+            min: 10,
+            scale: 0,
+        };
+        expect(canMinus(integerProps)).toBe(false);
+
+        const floatProps: Params = {
+            value: 0.2,
+            step: 0.4,
+            min: 0,
+            scale: 1,
+        };
+        expect(canMinus(floatProps)).toBe(false);
+    });
+});
+
+describe("getDisplayValue", () => {
+    test("**always** shows empty string if value is null (no value provided)", () => {
+        const displayValue1 = getDisplayValue({
+            value: null,
+            scale: null as unknown as number, // don't care
+        });
+        expect(displayValue1).toBe("");
+
+        const displayRenderer = jest.fn();
+        const displayValue2 = getDisplayValue({
+            value: null,
+            scale: null as unknown as number, // don't care
+            displayRenderer,
+        });
+        expect(displayValue2).toBe("");
+        expect(displayRenderer).not.toHaveBeenCalled();
+    });
+
+    test("uses custom display renderer if provided", () => {
+        const displayRenderer = jest.fn().mockReturnValue("CUSTOM DISPLAY VALUE");
+        const displayValue = getDisplayValue({
+            value: 1,
+            scale: 1,
+            displayRenderer,
+        });
+        expect(displayValue).toBe("CUSTOM DISPLAY VALUE");
+        expect(displayRenderer).toHaveBeenCalledTimes(1);
+    });
+
+    test("display the truncated value with `scale` number of decimal points when no custom display renderer", () => {
+        const displayValue1 = getDisplayValue({
+            value: 0.3,
+            scale: 4,
+        });
+        expect(displayValue1).toBe("0.3000");
+
+        const displayValue2 = getDisplayValue({
+            value: 0.1 + 0.2, // This should be something like 0.30000000000000004
+            scale: 4,
+        });
+        expect(displayValue2).toBe("0.3000");
+    });
+});
+
+describe("makeBestEffortToConvertEditingValueToValidNumber", () => {
+    type Config = Parameters<typeof rectifyInputIfValid>[1];
+
+    test("returns the userInput as a number (integer config)", () => {
+        expect.assertions(6);
+        const allowNullGetterSpy = jest.fn();
+        // prettier-ignore
+        const config: Config = {
+            min: 1, max: 10, scale: 0, get allowNull() { return allowNullGetterSpy() },
+        };
+        const createTest = (_: {inputText: string; expectedIntegerValue: number}) => ({
+            run: () => expect(rectifyInputIfValid(_.inputText, config)).toBe(_.expectedIntegerValue),
+        });
+        createTest({inputText: "1", expectedIntegerValue: 1}).run();
+        createTest({inputText: "1.0", expectedIntegerValue: 1}).run();
+        createTest({inputText: "2", expectedIntegerValue: 2}).run();
+        createTest({inputText: "10", expectedIntegerValue: 10}).run();
+        createTest({inputText: "10.0", expectedIntegerValue: 10}).run();
+        expect(allowNullGetterSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns the userInput as a number (float 2 decimal point config)", () => {
+        expect.assertions(6);
+        const allowNullGetterSpy = jest.fn();
+        // prettier-ignore
+        const config: Config = {
+            min: 0, max: 1, scale: 2, get allowNull() { return allowNullGetterSpy() },
+        };
+        const createTest = (_: {inputText: string; expectedFloatValue: number}) => ({
+            run: () => expect(rectifyInputIfValid(_.inputText, config)).toBe(_.expectedFloatValue),
+        });
+        createTest({inputText: "0", expectedFloatValue: 0}).run();
+        createTest({inputText: "0.0", expectedFloatValue: 0}).run();
+        createTest({inputText: "0.25", expectedFloatValue: 0.25}).run();
+        createTest({inputText: "1", expectedFloatValue: 1}).run();
+        createTest({inputText: "1.000", expectedFloatValue: 1}).run();
+        expect(allowNullGetterSpy).not.toHaveBeenCalled();
+    });
+
+    test("converts the userInput to a valid number (integer config)", () => {
+        expect.assertions(8);
+        const allowNullGetterSpy = jest.fn();
+        // prettier-ignore
+        const config: Config = {
+            min: 1, max: 10, scale: 0, get allowNull() { return allowNullGetterSpy() },
+        };
+        const createTest = (_: {convertibleText: string; expectedIntegerValue: number}) => ({
+            run: () => expect(rectifyInputIfValid(_.convertibleText, config)).toBe(_.expectedIntegerValue),
+        });
+        createTest({convertibleText: "0", expectedIntegerValue: 1}).run();
+        createTest({convertibleText: "0.1", expectedIntegerValue: 1}).run();
+        createTest({convertibleText: "1.000000001", expectedIntegerValue: 1}).run();
+        createTest({convertibleText: "4.4", expectedIntegerValue: 4}).run();
+        createTest({convertibleText: "4.9", expectedIntegerValue: 5}).run();
+        createTest({convertibleText: "9.999999999", expectedIntegerValue: 10}).run();
+        createTest({convertibleText: "10.4", expectedIntegerValue: 10}).run();
+        expect(allowNullGetterSpy).not.toHaveBeenCalled();
+    });
+
+    test("converts the userInput to a valid number (float 4 decimal point config)", () => {
+        expect.assertions(8);
+        const allowNullGetterSpy = jest.fn();
+        // prettier-ignore
+        const config: Config = {
+            min: 0, max: 1, scale: 4, get allowNull() { return allowNullGetterSpy() },
+        };
+        const createTest = (_: {convertibleText: string; expectedFloatValue: number}) => ({
+            run: () => expect(rectifyInputIfValid(_.convertibleText, config)).toBe(_.expectedFloatValue),
+        });
+        createTest({convertibleText: "0.000000000001", expectedFloatValue: 0}).run();
+        createTest({convertibleText: "0.0101", expectedFloatValue: 0.0101}).run();
+        createTest({convertibleText: "0.30000000000000004", expectedFloatValue: 0.3}).run();
+        createTest({convertibleText: "0.40999999999999999", expectedFloatValue: 0.41}).run();
+        createTest({convertibleText: "0.50069696969696969", expectedFloatValue: 0.5007}).run();
+        createTest({convertibleText: "0.50001", expectedFloatValue: 0.5}).run();
+        createTest({convertibleText: "1.00000000000000001", expectedFloatValue: 1}).run();
+        expect(allowNullGetterSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns magic string (invalid) if userInput cannot be converted (integer config)", () => {
+        expect.assertions(7);
+        const allowNullGetterSpy = jest.fn();
+        // prettier-ignore
+        const config: Config = {
+            min: 1, max: 10, scale: 0, get allowNull() { return allowNullGetterSpy() },
+        };
+        const createTest = (_: {unconvertibleText: string}) => ({
+            run: () => expect(rectifyInputIfValid(_.unconvertibleText, config)).toBe("@@INVALID"),
+        });
+        createTest({unconvertibleText: ","}).run();
+        createTest({unconvertibleText: "."}).run();
+        createTest({unconvertibleText: "1.0f"}).run();
+        createTest({unconvertibleText: "1.0.0"}).run();
+        createTest({unconvertibleText: "REEEEEEEEEEE"}).run();
+        createTest({unconvertibleText: "😄"}).run();
+        expect(allowNullGetterSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns magic string (invalid) if userInput cannot be converted (float 4 decimal point config)", () => {
+        expect.assertions(7);
+        const allowNullGetterSpy = jest.fn();
+        // prettier-ignore
+        const config: Config = {
+            min: 0, max: 1, scale: 4, get allowNull() { return allowNullGetterSpy() },
+        };
+        const createTest = (_: {unconvertibleText: string}) => ({
+            run: () => expect(rectifyInputIfValid(_.unconvertibleText, config)).toBe("@@INVALID"),
+        });
+        createTest({unconvertibleText: ","}).run();
+        createTest({unconvertibleText: "."}).run();
+        createTest({unconvertibleText: "1.0f"}).run();
+        createTest({unconvertibleText: "1.0.0"}).run();
+        createTest({unconvertibleText: "REEEEEEEEEEE"}).run();
+        createTest({unconvertibleText: "😄"}).run();
+        expect(allowNullGetterSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns null if userInput is empty string when `allowNull` is true", () => {
+        const allowNull = true;
+        const configPropertyGetterSpy = jest.fn();
+        const mockAllowNullGetter = jest.fn<boolean, []>().mockReturnValue(allowNull);
+        // prettier-ignore
+        const config = {
+            get min() { return configPropertyGetterSpy() },
+            get max() { return configPropertyGetterSpy() },
+            get scale() { return configPropertyGetterSpy() },
+            get allowNull() { return mockAllowNullGetter() },
+        };
+        const result = rectifyInputIfValid("", config);
+        expect(result).toBeNull();
+        expect(mockAllowNullGetter).toHaveBeenCalledWith();
+        expect(configPropertyGetterSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns magic string (invalid) if userInput is empty string when `allowNull` is false", () => {
+        const allowNull = false;
+        const configPropertyGetterSpy = jest.fn();
+        const mockAllowNullGetter = jest.fn<boolean, []>().mockReturnValue(allowNull);
+        // prettier-ignore
+        const config = {
+            get min() { return configPropertyGetterSpy() },
+            get max() { return configPropertyGetterSpy() },
+            get scale() { return configPropertyGetterSpy() },
+            get allowNull() { return mockAllowNullGetter() },
+        };
+        const result = rectifyInputIfValid("", config);
+        expect(result).toBe("@@INVALID");
+        expect(mockAllowNullGetter).toHaveBeenCalledWith();
+        expect(configPropertyGetterSpy).not.toHaveBeenCalled();
+    });
+});

package/test/unit-test/NumberUtil.test.ts

@@ -0,0 +1,57 @@
+import {NumberUtil} from "../../src/internal/NumberUtil";
+
+describe("NumberUtil.rounding", () => {
+    test("throws if `maxScale` is invalid", () => {
+        expect(() => NumberUtil.rounding(10, "round", -1)).toThrow();
+        expect(() => NumberUtil.rounding(10, "round", 1.1)).toThrow();
+    });
+
+    type TestEachRowSchema = {value: number; algorithm: "round" | "ceil" | "floor"; maxScale: any; expected: number};
+    test.each`
+        value    | algorithm  | maxScale | expected
+        ${3.65}  | ${"floor"} | ${0}     | ${3}
+        ${3.65}  | ${"floor"} | ${1}     | ${3.6}
+        ${3.65}  | ${"floor"} | ${2}     | ${3.65}
+        ${3.65}  | ${"floor"} | ${3}     | ${3.65}
+        ${7.45}  | ${"ceil"}  | ${0}     | ${8}
+        ${7.45}  | ${"ceil"}  | ${1}     | ${7.5}
+        ${7.45}  | ${"ceil"}  | ${2}     | ${7.45}
+        ${7.45}  | ${"ceil"}  | ${3}     | ${7.45}
+        ${1.664} | ${"round"} | ${0}     | ${2}
+        ${1.664} | ${"round"} | ${1}     | ${1.7}
+        ${1.664} | ${"round"} | ${2}     | ${1.66}
+        ${1.664} | ${"round"} | ${3}     | ${1.664}
+        ${1.664} | ${"round"} | ${4}     | ${1.664}
+        ${4.975} | ${"round"} | ${2}     | ${4.98}
+    `("rounding($value, '$algorithm', $maxScale) returns $expected", ({value, algorithm, maxScale, expected}: TestEachRowSchema) => {
+        expect(NumberUtil.rounding(value, algorithm, maxScale)).toBe(expected);
+    });
+});
+
+describe("NumberUtil.roundingToString", () => {
+    test("throws if `scale` is invalid", () => {
+        expect(() => NumberUtil.roundingToString(10, "round", -1)).toThrow();
+        expect(() => NumberUtil.roundingToString(10, "round", 1.1)).toThrow();
+    });
+
+    type TestEachRowSchema = {value: number; algorithm: "round" | "ceil" | "floor"; scale: any; expected: number};
+    test.each`
+        value    | algorithm  | scale | expected
+        ${3.65}  | ${"floor"} | ${0}  | ${"3"}
+        ${3.65}  | ${"floor"} | ${1}  | ${"3.6"}
+        ${3.65}  | ${"floor"} | ${2}  | ${"3.65"}
+        ${3.65}  | ${"floor"} | ${3}  | ${"3.650"}
+        ${7.45}  | ${"ceil"}  | ${0}  | ${"8"}
+        ${7.45}  | ${"ceil"}  | ${1}  | ${"7.5"}
+        ${7.45}  | ${"ceil"}  | ${2}  | ${"7.45"}
+        ${7.45}  | ${"ceil"}  | ${3}  | ${"7.450"}
+        ${1.664} | ${"round"} | ${0}  | ${"2"}
+        ${1.664} | ${"round"} | ${1}  | ${"1.7"}
+        ${1.664} | ${"round"} | ${2}  | ${"1.66"}
+        ${1.664} | ${"round"} | ${3}  | ${"1.664"}
+        ${1.664} | ${"round"} | ${4}  | ${"1.6640"}
+        ${4.975} | ${"round"} | ${2}  | ${"4.98"}
+    `("rounding($value, '$algorithm', $scale) returns '$expected'", ({value, algorithm, scale, expected}: TestEachRowSchema) => {
+        expect(NumberUtil.roundingToString(value, algorithm, scale)).toBe(expected);
+    });
+});

package/test/unit-test/TextUtil.test.ts

@@ -0,0 +1,10 @@
+import {TextUtil} from "@pinnacle0/web-ui/internal/TextUtil";
+
+describe("TextUtil.interpolate", () => {
+    test("interpolates values", () => {
+        expect(TextUtil.interpolate("{1} {2}", "hello", "world")).toBe("hello world");
+        expect(TextUtil.interpolate("{2} {3} {1}", "jest", "This", "is")).toBe("This is jest");
+        expect(TextUtil.interpolate("{3} {2} {1}", "a", "b", "c")).toBe("c b a");
+        expect(TextUtil.interpolate("{3} {2} {1}", "a", "b", "c", "d")).toBe("c b a");
+    });
+});

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+    "files": [],
+    "include": [],
+    "references": [
+        {
+            "path": "./config/tsconfig.script.json"
+        },
+        {
+            "path": "./config/tsconfig.src.json"
+        },
+        {
+            "path": "./config/tsconfig.test.json"
+        }
+    ]
+}

package/core/EnumSelect/index.d.ts

@@ -1,27 +0,0 @@
-import React from "react";
-import type { LabeledValue } from "antd/lib/select";
-import type { ControlledFormValue } from "../../internal/type";
-import { Nullable } from "./Nullable";
-import { InitialNullable } from "./InitialNullable";
-import { Map } from "./Map";
-import "./index.less";
-export interface BaseProps<Enum extends string | boolean | number> {
-    list: readonly Enum[];
-    translator?: (enumValue: Enum) => React.ReactChild;
-    disabled?: boolean;
-    className?: string;
-    style?: React.CSSProperties;
-    placeholder?: string;
-    suffixIcon?: React.ReactNode;
-}
-export interface Props<Enum extends string | boolean | number> extends BaseProps<Enum>, ControlledFormValue<Enum> {
-}
-export declare class EnumSelect<Enum extends string | boolean | number> extends React.PureComponent<Props<Enum>> {
-    static displayName: string;
-    static Nullable: typeof Nullable;
-    static InitialNullable: typeof InitialNullable;
-    static Map: typeof Map;
-    getAntSelectValue: () => LabeledValue | undefined;
-    onChange: ({ value: antValue }: LabeledValue) => void;
-    render(): JSX.Element;
-}

package/core/EnumSelect/index.js

@@ -1,58 +0,0 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import React from "react";
-import { Select } from "../Select";
-import { Nullable } from "./Nullable";
-import { InitialNullable } from "./InitialNullable";
-import { Map } from "./Map";
-import "./index.less";
-var EnumSelect = /** @class */ (function (_super) {
-    __extends(EnumSelect, _super);
-    function EnumSelect() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.getAntSelectValue = function () {
-            var value = _this.props.value;
-            if (value === null) {
-                // Special case for InitialNullable, to show placeholder, no pre-selection
-                return undefined;
-            }
-            var translator = _this.props.translator;
-            var antValue = value.toString();
-            var antLabel = translator ? translator(value) : antValue;
-            return {
-                value: antValue,
-                label: antLabel,
-            };
-        };
-        _this.onChange = function (_a) {
-            var antValue = _a.value;
-            var enumValue = antValue === "true" ? true : antValue === "false" ? false : antValue;
-            _this.props.onChange(enumValue);
-        };
-        return _this;
-    }
-    EnumSelect.prototype.render = function () {
-        var _a = this.props, list = _a.list, translator = _a.translator, disabled = _a.disabled, _b = _a.className, className = _b === void 0 ? "" : _b, style = _a.style, placeholder = _a.placeholder, suffixIcon = _a.suffixIcon;
-        return (React.createElement(Select, { disabled: disabled, labelInValue: true, value: this.getAntSelectValue(), onChange: this.onChange, className: "g-enum-select ".concat(className), style: style, placeholder: placeholder, suffixIcon: suffixIcon }, list.map(function (_) { return (React.createElement(Select.Option, { key: _.toString(), value: _.toString() }, translator ? translator(_) : _.toString())); })));
-    };
-    EnumSelect.displayName = "EnumSelect";
-    EnumSelect.Nullable = Nullable;
-    EnumSelect.InitialNullable = InitialNullable;
-    EnumSelect.Map = Map;
-    return EnumSelect;
-}(React.PureComponent));
-export { EnumSelect };
-//# sourceMappingURL=index.js.map

package/core/EnumSelect/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/EnumSelect/index.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,OAAO,EAAC,MAAM,EAAC,MAAM,WAAW,CAAC;AACjC,OAAO,EAAC,QAAQ,EAAC,MAAM,YAAY,CAAC;AACpC,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAC,GAAG,EAAC,MAAM,OAAO,CAAC;AAC1B,OAAO,cAAc,CAAC;AActB;IAAwE,8BAAgC;IAAxG;QAAA,qEAiDC;QA1CG,uBAAiB,GAAG;YAChB,IAAM,KAAK,GAAG,KAAI,CAAC,KAAK,CAAC,KAAa,CAAC;YACvC,IAAI,KAAK,KAAK,IAAI,EAAE;gBAChB,0EAA0E;gBAC1E,OAAO,SAAS,CAAC;aACpB;YAEM,IAAA,UAAU,GAAI,KAAI,CAAC,KAAK,WAAd,CAAe;YAChC,IAAM,QAAQ,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;YAClC,IAAM,QAAQ,GAAG,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;YAC3D,OAAO;gBACH,KAAK,EAAE,QAAQ;gBACf,KAAK,EAAE,QAAQ;aAClB,CAAC;QACN,CAAC,CAAC;QAEF,cAAQ,GAAG,UAAC,EAA+B;gBAAvB,QAAQ,WAAA;YACxB,IAAM,SAAS,GAAG,QAAQ,KAAK,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC;YACvF,KAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAgB,CAAC,CAAC;QAC1C,CAAC,CAAC;;IAuBN,CAAC;IArBG,2BAAM,GAAN;QACU,IAAA,KAA+E,IAAI,CAAC,KAAK,EAAxF,IAAI,UAAA,EAAE,UAAU,gBAAA,EAAE,QAAQ,cAAA,EAAE,iBAAc,EAAd,SAAS,mBAAG,EAAE,KAAA,EAAE,KAAK,WAAA,EAAE,WAAW,iBAAA,EAAE,UAAU,gBAAc,CAAC;QAChG,OAAO,CACH,oBAAC,MAAM,IACH,QAAQ,EAAE,QAAQ,EAClB,YAAY,QACZ,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,EAC/B,QAAQ,EAAE,IAAI,CAAC,QAAQ,EACvB,SAAS,EAAE,wBAAiB,SAAS,CAAE,EACvC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,UAAU,IAErB,IAAI,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CACX,oBAAC,MAAM,CAAC,MAAM,IAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,QAAQ,EAAE,IAChD,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAC9B,CACnB,EAJc,CAId,CAAC,CACG,CACZ,CAAC;IACN,CAAC;IA/CM,sBAAW,GAAG,YAAY,CAAC;IAE3B,mBAAQ,GAAG,QAAQ,CAAC;IACpB,0BAAe,GAAG,eAAe,CAAC;IAClC,cAAG,GAAG,GAAG,CAAC;IA4CrB,iBAAC;CAAA,AAjDD,CAAwE,KAAK,CAAC,aAAa,GAiD1F;SAjDY,UAAU"}