@pinnacle0/web-ui 0.3.35 → 0.3.36

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/admin/AdminApp/Default/NavigatorSide/index.d.ts

@@ -1,20 +0,0 @@
-import React from "react";
-import "./index.less";
-declare type DrawerUserInfo = {
-    [title: string]: React.ReactElement | string | null;
-};
-interface Props {
-    onLogout: () => void;
-    drawerInfo: DrawerUserInfo;
-}
-interface State {
-    showDrawer: boolean;
-}
-export declare class NavigatorSide extends React.PureComponent<Props, State> {
-    static displayName: string;
-    constructor(props: Props);
-    showDrawer: () => void;
-    closeDrawer: () => void;
-    render(): JSX.Element;
-}
-export {};

package/admin/AdminApp/Default/NavigatorSide/index.js

@@ -1,74 +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 __());
-    };
-})();
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-import React from "react";
-import UserOutlined from "@ant-design/icons/UserOutlined";
-import { Button } from "../../../../core/Button";
-import { Drawer } from "../../../../core/Drawer";
-import { i18n } from "../../../../internal/i18n/admin";
-import "./index.less";
-var NavigatorSide = /** @class */ (function (_super) {
-    __extends(NavigatorSide, _super);
-    function NavigatorSide(props) {
-        var _this = _super.call(this, props) || this;
-        _this.showDrawer = function () { return _this.setState({ showDrawer: true }); };
-        _this.closeDrawer = function () { return _this.setState({ showDrawer: false }); };
-        _this.state = {
-            showDrawer: false,
-        };
-        return _this;
-    }
-    NavigatorSide.prototype.render = function () {
-        var t = i18n();
-        var _a = this.props, onLogout = _a.onLogout, drawerInfo = _a.drawerInfo;
-        var showDrawer = this.state.showDrawer;
-        return (React.createElement(React.Fragment, null,
-            React.createElement(Button, { id: "admin-app-default-navigator-side-button", size: "small", onClick: this.showDrawer },
-                React.createElement(UserOutlined, null)),
-            React.createElement(Drawer, { width: 350, visible: showDrawer, closable: false, onClose: this.closeDrawer },
-                React.createElement("div", { id: "admin-app-default-drawer" },
-                    React.createElement(UserOutlined, { className: "avatar" }),
-                    React.createElement("div", { className: "grid" }, Object.entries(drawerInfo).map(function (_a, index) {
-                        var _b = __read(_a, 2), title = _b[0], node = _b[1];
-                        if (node) {
-                            return (React.createElement("div", { className: "row", key: index },
-                                React.createElement("b", { className: "label" }, title),
-                                node));
-                        }
-                    })),
-                    React.createElement("div", { className: "bottom" },
-                        React.createElement(Button, { size: "large", onClick: onLogout }, t.logout))))));
-    };
-    NavigatorSide.displayName = "NavigatorSide";
-    return NavigatorSide;
-}(React.PureComponent));
-export { NavigatorSide };
-//# sourceMappingURL=index.js.map

package/admin/AdminApp/Default/NavigatorSide/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/admin/AdminApp/Default/NavigatorSide/index.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,YAAY,MAAM,gCAAgC,CAAC;AAC1D,OAAO,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAC/C,OAAO,EAAC,IAAI,EAAC,MAAM,iCAAiC,CAAC;AACrD,OAAO,cAAc,CAAC;AAatB;IAAmC,iCAAiC;IAGhE,uBAAY,KAAY;QAAxB,YACI,kBAAM,KAAK,CAAC,SAIf;QAED,gBAAU,GAAG,cAAM,OAAA,KAAI,CAAC,QAAQ,CAAC,EAAC,UAAU,EAAE,IAAI,EAAC,CAAC,EAAjC,CAAiC,CAAC;QAErD,iBAAW,GAAG,cAAM,OAAA,KAAI,CAAC,QAAQ,CAAC,EAAC,UAAU,EAAE,KAAK,EAAC,CAAC,EAAlC,CAAkC,CAAC;QAPnD,KAAI,CAAC,KAAK,GAAG;YACT,UAAU,EAAE,KAAK;SACpB,CAAC;;IACN,CAAC;IAMD,8BAAM,GAAN;QACI,IAAM,CAAC,GAAG,IAAI,EAAE,CAAC;QACX,IAAA,KAAyB,IAAI,CAAC,KAAK,EAAlC,QAAQ,cAAA,EAAE,UAAU,gBAAc,CAAC;QACnC,IAAA,UAAU,GAAI,IAAI,CAAC,KAAK,WAAd,CAAe;QAEhC,OAAO,CACH,oBAAC,KAAK,CAAC,QAAQ;YACX,oBAAC,MAAM,IAAC,EAAE,EAAC,yCAAyC,EAAC,IAAI,EAAC,OAAO,EAAC,OAAO,EAAE,IAAI,CAAC,UAAU;gBACtF,oBAAC,YAAY,OAAG,CACX;YACT,oBAAC,MAAM,IAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW;gBAC/E,6BAAK,EAAE,EAAC,0BAA0B;oBAC9B,oBAAC,YAAY,IAAC,SAAS,EAAC,QAAQ,GAAG;oBACnC,6BAAK,SAAS,EAAC,MAAM,IAChB,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,UAAC,EAAa,EAAE,KAAK;4BAApB,KAAA,aAAa,EAAZ,KAAK,QAAA,EAAE,IAAI,QAAA;wBACzC,IAAI,IAAI,EAAE;4BACN,OAAO,CACH,6BAAK,SAAS,EAAC,KAAK,EAAC,GAAG,EAAE,KAAK;gCAC3B,2BAAG,SAAS,EAAC,OAAO,IAAE,KAAK,CAAK;gCAC/B,IAAI,CACH,CACT,CAAC;yBACL;oBACL,CAAC,CAAC,CACA;oBACN,6BAAK,SAAS,EAAC,QAAQ;wBACnB,oBAAC,MAAM,IAAC,IAAI,EAAC,OAAO,EAAC,OAAO,EAAE,QAAQ,IACjC,CAAC,CAAC,MAAM,CACJ,CACP,CACJ,CACD,CACI,CACpB,CAAC;IACN,CAAC;IA/CM,yBAAW,GAAG,eAAe,CAAC;IAgDzC,oBAAC;CAAA,AAjDD,CAAmC,KAAK,CAAC,aAAa,GAiDrD;SAjDY,aAAa"}

package/admin/AdminApp/Default/SoundSwitch.d.ts

@@ -1,14 +0,0 @@
-import React from "react";
-interface Props {
-}
-interface State {
-    soundEnabled: boolean;
-}
-export declare class SoundSwitch extends React.PureComponent<Props, State> {
-    static displayName: string;
-    private readonly soundEnabledKey;
-    constructor(props: Props);
-    toggleSoundSwitch: () => void;
-    render(): JSX.Element;
-}
-export {};

package/admin/AdminApp/Default/SoundSwitch.js

@@ -1,41 +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 { LocalStorageUtil } from "../../../util/LocalStorageUtil";
-import { BoolSwitch } from "../../../core/BoolSwitch";
-var SoundSwitch = /** @class */ (function (_super) {
-    __extends(SoundSwitch, _super);
-    function SoundSwitch(props) {
-        var _this = _super.call(this, props) || this;
-        _this.soundEnabledKey = "admin-sound-enabled";
-        _this.toggleSoundSwitch = function () {
-            var newValue = !_this.state.soundEnabled;
-            _this.setState({ soundEnabled: newValue });
-            LocalStorageUtil.setBool(_this.soundEnabledKey, newValue);
-        };
-        _this.state = {
-            soundEnabled: LocalStorageUtil.getBool(_this.soundEnabledKey, true),
-        };
-        return _this;
-    }
-    SoundSwitch.prototype.render = function () {
-        return React.createElement(BoolSwitch.OnOff, { value: this.state.soundEnabled, onChange: this.toggleSoundSwitch });
-    };
-    SoundSwitch.displayName = "SoundSwitch";
-    return SoundSwitch;
-}(React.PureComponent));
-export { SoundSwitch };
-//# sourceMappingURL=SoundSwitch.js.map

package/admin/AdminApp/Default/SoundSwitch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SoundSwitch.js","sourceRoot":"","sources":["../../../../src/admin/AdminApp/Default/SoundSwitch.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,OAAO,EAAC,gBAAgB,EAAC,MAAM,gCAAgC,CAAC;AAChE,OAAO,EAAC,UAAU,EAAC,MAAM,0BAA0B,CAAC;AAQpD;IAAiC,+BAAiC;IAK9D,qBAAY,KAAY;QAAxB,YACI,kBAAM,KAAK,CAAC,SAIf;QAPgB,qBAAe,GAAG,qBAAqB,CAAC;QASzD,uBAAiB,GAAG;YAChB,IAAM,QAAQ,GAAG,CAAC,KAAI,CAAC,KAAK,CAAC,YAAY,CAAC;YAC1C,KAAI,CAAC,QAAQ,CAAC,EAAC,YAAY,EAAE,QAAQ,EAAC,CAAC,CAAC;YACxC,gBAAgB,CAAC,OAAO,CAAC,KAAI,CAAC,eAAe,EAAE,QAAQ,CAAC,CAAC;QAC7D,CAAC,CAAC;QATE,KAAI,CAAC,KAAK,GAAG;YACT,YAAY,EAAE,gBAAgB,CAAC,OAAO,CAAC,KAAI,CAAC,eAAe,EAAE,IAAI,CAAC;SACrE,CAAC;;IACN,CAAC;IAQD,4BAAM,GAAN;QACI,OAAO,oBAAC,UAAU,CAAC,KAAK,IAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,iBAAiB,GAAI,CAAC;IAClG,CAAC;IAnBM,uBAAW,GAAG,aAAa,CAAC;IAoBvC,kBAAC;CAAA,AArBD,CAAiC,KAAK,CAAC,aAAa,GAqBnD;SArBY,WAAW"}