@etsoo/shared 1.2.54 → 1.2.55

package/__tests__/DataTypes.ts

@@ -1,218 +1,236 @@
-import { DataTypes, IdDefaultType, LabelDefaultType } from '../src/DataTypes';
-
-test('Tests for DI', () => {
-    const item: DataTypes.DIS<'id', number> & DataTypes.DIS<'label', string> = {
-        id: 1,
-        label: 'Etsoo'
-    };
-    expect(item.id).toBe(1);
-});
-
-test('Tests for IdLabelType', () => {
-    const item: DataTypes.IdLabelItem = {
-        id: 1,
-        label: 'Etsoo'
-    };
-    const itemCopy: DataTypes.IdLabelType<'id', 'label'> = { ...item };
-    expect(item).toEqual(itemCopy);
+import { DataTypes, IdDefaultType, LabelDefaultType } from "../src/DataTypes";
+
+test("Tests for DI", () => {
+  const item: DataTypes.DIS<"id", number> & DataTypes.DIS<"label", string> = {
+    id: 1,
+    label: "Etsoo"
+  };
+  expect(item.id).toBe(1);
+});
+
+test("Tests for IdLabelType", () => {
+  const item: DataTypes.IdLabelItem = {
+    id: 1,
+    label: "Etsoo"
+  };
+  const itemCopy: DataTypes.IdLabelType<"id", "label"> = { ...item };
+  expect(item).toEqual(itemCopy);
 });
 
-test('Tests for Bigint Type', () => {
-    type BigintType = {
-        id: bigint;
-        label: string;
-    };
-
-    const item: BigintType = {
-        id: 9007199254740999n,
-        label: 'Etsoo'
-    };
+test("Tests for Bigint Type", () => {
+  type BigintType = {
+    id: bigint;
+    label: string;
+  };
+
+  const item: BigintType = {
+    id: 9007199254740999n,
+    label: "Etsoo"
+  };
 
-    const json = JSON.stringify(item);
-    expect(json).toBe('{"id":"9007199254740999n","label":"Etsoo"}');
-
-    const itemBack = JSON.parse(
-        json,
-        DataTypes.jsonBigintReceiver('id')
-    ) as BigintType;
-    expect(itemBack.id).toBe(9007199254740999n);
+  const json = JSON.stringify(item);
+  expect(json).toBe('{"id":"9007199254740999n","label":"Etsoo"}');
+
+  const itemBack = JSON.parse(
+    json,
+    DataTypes.jsonBigintReceiver("id")
+  ) as BigintType;
+  expect(itemBack.id).toBe(9007199254740999n);
 });
-
-test('Tests for convert', () => {
-    expect(DataTypes.convert('5', 0)).toStrictEqual(5);
-    expect(
-        DataTypes.convert('2021/10/13', new Date())?.getDate()
-    ).toStrictEqual(13);
-    expect(DataTypes.convert('a', [])?.length).toStrictEqual(1);
-    expect(DataTypes.convert('1', [0])).toStrictEqual([1]);
-    expect(DataTypes.convert('', 0)).toBeUndefined();
-    expect(DataTypes.convert('false', true)).toBeFalsy();
-    expect(DataTypes.convert('1', true)).toBeTruthy();
-    expect(DataTypes.convert(true, true)).toBeTruthy();
+
+test("Tests for convert", () => {
+  expect(DataTypes.convert("5", 0)).toStrictEqual(5);
+  expect(DataTypes.convert("2021/10/13", new Date())?.getDate()).toStrictEqual(
+    13
+  );
+  expect(DataTypes.convert("a", [])?.length).toStrictEqual(1);
+  expect(DataTypes.convert("1", [0])).toStrictEqual([1]);
+  expect(DataTypes.convert("", 0)).toBeUndefined();
+  expect(DataTypes.convert("false", true)).toBeFalsy();
+  expect(DataTypes.convert("1", true)).toBeTruthy();
+  expect(DataTypes.convert(true, true)).toBeTruthy();
 });
 
-test('Tests for convertByType', () => {
-    expect(DataTypes.convertByType('', 'number')).toBeUndefined();
-    expect(DataTypes.convertByType('', 'string')).toBeUndefined();
-    expect(DataTypes.convertByType('', 'boolean')).toBeUndefined();
-    expect(DataTypes.convertByType(['5', 8], 'number[]')).toStrictEqual([5, 8]);
-    expect(DataTypes.convertByType(['5', 8], 'string[]')).toStrictEqual([
-        '5',
-        '8'
-    ]);
-    expect(
-        DataTypes.convertByType('2021/10/13', 'date')?.getDate()
-    ).toStrictEqual(13);
+test("Tests for convertByType", () => {
+  expect(DataTypes.convertByType("", "number")).toBeUndefined();
+  expect(DataTypes.convertByType("", "string")).toBeUndefined();
+  expect(DataTypes.convertByType("", "boolean")).toBeUndefined();
+  expect(DataTypes.convertByType(["5", 8], "number[]")).toStrictEqual([5, 8]);
+  expect(DataTypes.convertByType(["5", 8], "string[]")).toStrictEqual([
+    "5",
+    "8"
+  ]);
+  expect(
+    DataTypes.convertByType("2021/10/13", "date")?.getDate()
+  ).toStrictEqual(13);
 });
 
-test('Tests for convertSimple', () => {
-    expect(
-        DataTypes.convertSimple(5.8, DataTypes.CombinedEnum.Int)
-    ).toStrictEqual(6);
-    expect(
-        DataTypes.convertSimple(5.88293, DataTypes.CombinedEnum.Money)
-    ).toStrictEqual(5.8829);
-});
-
-test('Tests for getBasicName', () => {
-    expect(
-        DataTypes.getBasicName(DataTypes.CombinedEnum.DateTime)
-    ).toStrictEqual('date');
+test("Tests for convertSimple", () => {
+  expect(
+    DataTypes.convertSimple(5.8, DataTypes.CombinedEnum.Int)
+  ).toStrictEqual(6);
+  expect(
+    DataTypes.convertSimple(5.88293, DataTypes.CombinedEnum.Money)
+  ).toStrictEqual(5.8829);
+});
+
+test("Tests for getBasicName", () => {
+  expect(DataTypes.getBasicName(DataTypes.CombinedEnum.DateTime)).toStrictEqual(
+    "date"
+  );
 });
 
-test('Tests for getEnumByKey', () => {
-    expect(
-        DataTypes.getEnumByKey(DataTypes.HAlignEnum, 'Center')
-    ).toStrictEqual(DataTypes.HAlignEnum.Center);
-
-    expect(
-        DataTypes.getEnumByKey(DataTypes.HAlignEnum, 'Unknown')
-    ).toBeUndefined();
-});
-
-test('Tests for getEnumByValue', () => {
-    expect(DataTypes.getEnumByValue(DataTypes.HAlignEnum, 2)).toStrictEqual(
-        DataTypes.HAlignEnum.Center
-    );
-
-    expect(DataTypes.getEnumByValue(DataTypes.HAlignEnum, 4)).toBeUndefined();
-});
-
-test('Tests for getEnumKey', () => {
-    expect(
-        DataTypes.getEnumKey(DataTypes.HAlignEnum, DataTypes.HAlignEnum.Center)
-    ).toBe('Center');
-});
-
-test('Tests for getEnumKeys', () => {
-    enum ProductUnit {
-        KILOGRAM = 32,
-        GRAM = 'GRAM33'
-    }
-    expect(DataTypes.getEnumKeys(ProductUnit)).toContainEqual('GRAM');
-
-    const keys = DataTypes.getEnumKeys(DataTypes.CombinedEnum);
-    expect(keys).toContainEqual('Unkwown');
-});
-
-test('Tests for IdLabelItem', () => {
-    // Arrange
-    const items: DataTypes.IdLabelItem[] = [
-        { id: 1, label: 'Item 1' },
-        { id: 2, label: 'Item 2' }
-    ];
-
-    // Assert
-    expect(items[0].id).toBe(1);
-    expect(items[1].label).toBe('Item 2');
-});
-
-test('Tests for getValue', () => {
-    const data = { id: 1, flag: true };
-    expect(DataTypes.getValue(data, 'id')).toBe(1);
-    expect(DataTypes.getValue(data, 'flag')).toBeTruthy();
-    expect(DataTypes.getValue(data, 'unknown')).toBeUndefined();
-});
-
-test('Tests for getIdValue', () => {
-    const data = { id: 1, flag: true, field: 'string' };
-    expect(DataTypes.getIdValue(data, 'id')).toBe(1);
-    expect(DataTypes.getIdValue(data, 'field')).toBe('string');
-});
-
-test('Tests for getStringValue', () => {
-    const data = { id: 1, flag: true };
-    expect(DataTypes.getStringValue(data, 'id')).toBe('1');
-    expect(DataTypes.getStringValue(data, 'flag')).toBe('true');
-});
-
-test('Tests for isSimpleType', () => {
-    expect(DataTypes.isSimpleType(1)).toBeTruthy();
-    expect(DataTypes.isSimpleType(new Date())).toBeTruthy();
-    expect(DataTypes.isSimpleType(Symbol())).toBeFalsy();
-    expect(DataTypes.isSimpleType(['a', 'b', 'c'])).toBeTruthy();
-    expect(DataTypes.isSimpleType({})).toBeFalsy();
-});
-
-test('Tests for IdDefaultType', () => {
-    const test = <T extends object, F extends keyof T = IdDefaultType<T>>(
-        obj: T,
-        field?: F
-    ) => {
-        const f = field ?? ('id' as F);
-        return obj[f];
-    };
+test("Tests for getEnumByKey", () => {
+  expect(DataTypes.getEnumByKey(DataTypes.HAlignEnum, "Center")).toStrictEqual(
+    DataTypes.HAlignEnum.Center
+  );
+
+  expect(
+    DataTypes.getEnumByKey(DataTypes.HAlignEnum, "Unknown")
+  ).toBeUndefined();
+});
+
+test("Tests for getEnumByValue", () => {
+  expect(DataTypes.getEnumByValue(DataTypes.HAlignEnum, 2)).toStrictEqual(
+    DataTypes.HAlignEnum.Center
+  );
+
+  expect(DataTypes.getEnumByValue(DataTypes.HAlignEnum, 4)).toBeUndefined();
+});
+
+test("Tests for getEnumKey", () => {
+  expect(
+    DataTypes.getEnumKey(DataTypes.HAlignEnum, DataTypes.HAlignEnum.Center)
+  ).toBe("Center");
+});
+
+test("Tests for getEnumKeys", () => {
+  enum ProductUnit {
+    KILOGRAM = 32,
+    GRAM = "GRAM33"
+  }
+  expect(DataTypes.getEnumKeys(ProductUnit)).toContainEqual("GRAM");
+
+  const keys = DataTypes.getEnumKeys(DataTypes.CombinedEnum);
+  expect(keys).toContainEqual("Unkwown");
+});
+
+test("Tests for IdLabelItem", () => {
+  // Arrange
+  const items: DataTypes.IdLabelItem[] = [
+    { id: 1, label: "Item 1" },
+    { id: 2, label: "Item 2" }
+  ];
+
+  // Assert
+  expect(items[0].id).toBe(1);
+  expect(items[1].label).toBe("Item 2");
+});
+
+test("Tests for getValue", () => {
+  const data = { id: 1, flag: true };
+  expect(DataTypes.getValue(data, "id")).toBe(1);
+  expect(DataTypes.getValue(data, "flag")).toBeTruthy();
+  expect(DataTypes.getValue(data, "unknown")).toBeUndefined();
+});
+
+test("Tests for getIdValue", () => {
+  const data = { id: 1, flag: true, field: "string" };
+  expect(DataTypes.getIdValue(data, "id")).toBe(1);
+  expect(DataTypes.getIdValue(data, "field")).toBe("string");
+});
+
+test("Tests for getStringValue", () => {
+  const data = { id: 1, flag: true };
+  expect(DataTypes.getStringValue(data, "id")).toBe("1");
+  expect(DataTypes.getStringValue(data, "flag")).toBe("true");
+});
+
+test("Tests for isSimpleType", () => {
+  expect(DataTypes.isSimpleType(1)).toBeTruthy();
+  expect(DataTypes.isSimpleType(new Date())).toBeTruthy();
+  expect(DataTypes.isSimpleType(Symbol())).toBeFalsy();
+  expect(DataTypes.isSimpleType(["a", "b", "c"])).toBeTruthy();
+  expect(DataTypes.isSimpleType({})).toBeFalsy();
+});
+
+test("Tests for IdDefaultType", () => {
+  const test = <T extends object, F extends keyof T = IdDefaultType<T>>(
+    obj: T,
+    field?: F
+  ) => {
+    const f = field ?? ("id" as F);
+    return obj[f];
+  };
 
-    type D = { label: string; name: string; id: number };
-    const data: D = {
-        label: 'label',
-        name: 'name',
-        id: 1
-    };
-    const v = test<D>(data);
-    expect(typeof v).toBe('number');
+  type D = { label: string; name: string; id: number };
+  const data: D = {
+    label: "label",
+    name: "name",
+    id: 1
+  };
+  const v = test<D>(data);
+  expect(typeof v).toBe("number");
 
-    const v1 = test<D, LabelDefaultType<D>>(data, 'label');
-    expect(v1).toBe('label');
-});
-
-test('Tests for jsonReplacer', () => {
-    const obj = { a: 1, b: 'hello', c: { c1: 'C1', c2: false, c3: 128 } };
+  const v1 = test<D, LabelDefaultType<D>>(data, "label");
+  expect(v1).toBe("label");
+});
+
+test("Tests for jsonReplacer", () => {
+  const obj = { a: 1, b: "hello", c: { c1: "C1", c2: false, c3: 128 } };
 
-    const json1 = JSON.stringify(
-        obj,
-        DataTypes.jsonReplacer(function (key, value, path) {
-            if (['', 'a'].includes(key)) {
-                return value;
-            }
-            return undefined;
-        })
-    );
-    expect(json1).toBe('{"a":1}');
-
-    const json2 = JSON.stringify(
-        obj,
-        DataTypes.jsonReplacer(function (key, value, path) {
-            if (['', 'c'].includes(key) || path === 'c.c2') {
-                return value;
-            }
-            return undefined;
-        })
-    );
-    expect(json2).toBe('{"c":{"c2":false}}');
-});
-
-test('Tests for AddAndEditType', () => {
-    type Entity = DataTypes.AddAndEditType<{
-        id: number;
-        name: string;
-        age?: number;
-    }>;
-
-    const data1: Entity = { id: 1, name: 'hello', changedFields: ['name'] };
-    const data2: Entity = { id: undefined, name: 'hello' };
-    const data3: Entity = { name: 'hello' };
-
-    expect(data1.name).toBe(data2.name);
-    expect(data2.name).toBe(data3.name);
+  const json1 = JSON.stringify(
+    obj,
+    DataTypes.jsonReplacer(function (key, value, path) {
+      if (["", "a"].includes(key)) {
+        return value;
+      }
+      return undefined;
+    })
+  );
+  expect(json1).toBe('{"a":1}');
+
+  const json2 = JSON.stringify(
+    obj,
+    DataTypes.jsonReplacer(function (key, value, path) {
+      if (["", "c"].includes(key) || path === "c.c2") {
+        return value;
+      }
+      return undefined;
+    })
+  );
+  expect(json2).toBe('{"c":{"c2":false}}');
+});
+
+test("Tests for AddAndEditType", () => {
+  type Entity = DataTypes.AddAndEditType<{
+    id: number;
+    name: string;
+    age?: number;
+  }>;
+
+  const data1: Entity = { id: 1, name: "hello", changedFields: ["name"] };
+  const data2: Entity = { id: undefined, name: "hello" };
+  const data3: Entity = { name: "hello" };
+
+  expect(data1.name).toBe(data2.name);
+  expect(data2.name).toBe(data3.name);
+});
+
+test("Tests for BasicTemplate", () => {
+  const template: DataTypes.BasicTemplate = {
+    id: "number",
+    name: "string",
+    birthday: "date"
+  };
+
+  const data: { currentPage?: number } & DataTypes.BasicTemplateType<
+    typeof template
+  > = {
+    id: 1,
+    name: "Etsoo",
+    birthday: new Date()
+  };
+
+  expect(data.id).toBe(1);
 });

package/__tests__/DateUtils.ts

@@ -1,40 +1,40 @@
-import { DateUtils } from '../src/DateUtils';
+import { DateUtils } from "../src/DateUtils";
 
-test('Tests for local date time', () => {
-    // Arrange
-    const date = new Date('2021-06-12T02:23:06');
+test("Tests for local date time", () => {
+  // Arrange
+  const date = new Date("2021-06-12T02:23:06");
 
-    // Act & assert
-    expect(DateUtils.format(date, 'zh-CN', 'd')).toBe('2021/06/12');
-    expect(DateUtils.format(date, 'en-US', 'dm')).toBe('06/12/2021 02:23');
-    expect(DateUtils.format(date, 'en-NZ', 'ds')).toBe('12/06/2021 02:23:06');
+  // Act & assert
+  expect(DateUtils.format(date, "zh-CN", "d")).toBe("2021/06/12");
+  expect(DateUtils.format(date, "en-US", "dm")).toBe("06/12/2021 02:23");
+  expect(DateUtils.format(date, "en-NZ", "ds")).toBe("12/06/2021 02:23:06");
 });
 
-test('Tests for UTC date time', () => {
-    // Arrange
-    const utc1 = new Date('2021-06-12T02:23:06.000Z');
+test("Tests for UTC date time", () => {
+  // Arrange
+  const utc1 = new Date("2021-06-12T02:23:06.000Z");
 
-    // Act & assert
-    expect(DateUtils.format(utc1, 'en-NZ', 'ds', 'Pacific/Auckland')).toBe(
-        '12/06/2021 14:23:06'
-    );
+  // Act & assert
+  expect(DateUtils.format(utc1, "en-NZ", "ds", "Pacific/Auckland")).toBe(
+    "12/06/2021 14:23:06"
+  );
 
-    const utc2 = new Date('2021-06-12T02:23:06.000Z');
+  const utc2 = new Date("2021-06-12T02:23:06.000Z");
 
-    expect(DateUtils.format(utc2, 'en-US', 'ds', 'America/New_York')).toBe(
-        '06/11/2021 22:23:06'
-    );
+  expect(DateUtils.format(utc2, "en-US", "ds", "America/New_York")).toBe(
+    "06/11/2021 22:23:06"
+  );
 });
 
-test('Tests for getDays', () => {
-    expect(DateUtils.getDays(2021, 1)).toBe(28);
-    expect(DateUtils.getDays(2009, 1)).toBe(28);
-    expect(DateUtils.getDays(2008, 1)).toBe(29);
-    expect(DateUtils.getDays(2000, 1)).toBe(29);
+test("Tests for getDays", () => {
+  expect(DateUtils.getDays(2021, 1)).toBe(28);
+  expect(DateUtils.getDays(2009, 1)).toBe(28);
+  expect(DateUtils.getDays(2008, 1)).toBe(29);
+  expect(DateUtils.getDays(2000, 1)).toBe(29);
 });
 
-test('Tests for date parse', () => {
-    const json = `
+test("Tests for date parse", () => {
+  const json = `
     {   
         "id": 1234, 
         "logined": false,   
@@ -44,81 +44,81 @@ test('Tests for date parse', () => {
     }
     `;
 
-    const result = JSON.parse(json, DateUtils.jsonParser(['creation']));
-    const isDate = result.creation instanceof Date;
-    const isIdDate = result.externalId instanceof Date;
+  const result = JSON.parse(json, DateUtils.jsonParser(["creation"]));
+  const isDate = result.creation instanceof Date;
+  const isIdDate = result.externalId instanceof Date;
 
-    expect(isIdDate).toBeFalsy();
-    expect(isDate).toBeTruthy();
+  expect(isIdDate).toBeFalsy();
+  expect(isDate).toBeTruthy();
 });
 
-test('Tests for formatForInput', () => {
-    const result1 = DateUtils.formatForInput('2021/7/17');
-    expect(result1).toBe('2021-07-17');
+test("Tests for formatForInput", () => {
+  const result1 = DateUtils.formatForInput("2021/7/17");
+  expect(result1).toBe("2021-07-17");
 
-    const d = new Date(2021, 5, 6, 20, 8, 45);
-    const result2 = DateUtils.formatForInput(d);
-    expect(result2).toBe('2021-06-06');
+  const d = new Date(2021, 5, 6, 20, 8, 45);
+  const result2 = DateUtils.formatForInput(d);
+  expect(result2).toBe("2021-06-06");
 
-    const result3 = DateUtils.formatForInput(d, false);
-    expect(result3).toBe('2021-06-06T20:08');
+  const result3 = DateUtils.formatForInput(d, false);
+  expect(result3).toBe("2021-06-06T20:08");
 
-    const result31 = DateUtils.formatForInput(d, 'date');
-    expect(result31).toBe('2021-06-06');
+  const result31 = DateUtils.formatForInput(d, "date");
+  expect(result31).toBe("2021-06-06");
 
-    const result4 = DateUtils.formatForInput(d, true);
-    expect(result4).toBe('2021-06-06T20:08:45');
+  const result4 = DateUtils.formatForInput(d, true);
+  expect(result4).toBe("2021-06-06T20:08:45");
 
-    const result41 = DateUtils.formatForInput(d, 'datetime-local');
-    expect(result41).toBe('2021-06-06T20:08:45');
+  const result41 = DateUtils.formatForInput(d, "datetime-local");
+  expect(result41).toBe("2021-06-06T20:08:45");
 
-    const result5 = DateUtils.formatForInput('');
-    expect(result5).toBeUndefined();
+  const result5 = DateUtils.formatForInput("");
+  expect(result5).toBeUndefined();
 
-    const result51 = DateUtils.formatForInput(null);
-    expect(result51).toBeUndefined();
+  const result51 = DateUtils.formatForInput(null);
+  expect(result51).toBeUndefined();
 });
 
-test('Tests for isExpired', () => {
-    expect(DateUtils.isExpired(null)).toBeFalsy();
-    expect(DateUtils.isExpired('2020/1/1')).toBeTruthy();
-    expect(DateUtils.isExpired('9999/1/1')).toBeFalsy();
+test("Tests for isExpired", () => {
+  expect(DateUtils.isExpired(null)).toBeFalsy();
+  expect(DateUtils.isExpired("2020/1/1")).toBeTruthy();
+  expect(DateUtils.isExpired("9999/1/1")).toBeFalsy();
 });
 
-test('Tests for substract', () => {
-    const d1 = new Date('2021/1/13 12:00:00');
-    const d2 = new Date('2022/1/13 12:00:00');
-    const d3 = new Date('2022/1/13 12:10:01');
-    const d4 = new Date('2023/1/12 12:00:00');
-    expect(d3.substract(d1).totalYears > 1).toBeTruthy();
-    expect(d4.substract(d1).totalYears < 2).toBeTruthy();
-    expect(d2.substract(d1).totalMinutes > 10).toBeTruthy();
+test("Tests for substract", () => {
+  const d1 = new Date("2021/1/13 12:00:00");
+  const d2 = new Date("2022/1/13 12:00:00");
+  const d3 = new Date("2022/1/13 12:10:01");
+  const d4 = new Date("2023/1/12 12:00:00");
+  expect(d3.substract(d1).totalYears > 1).toBeTruthy();
+  expect(d4.substract(d1).totalYears < 2).toBeTruthy();
+  expect(d2.substract(d1).totalMinutes > 10).toBeTruthy();
 });
 
-test('Tests for parse', () => {
-    const d1 = DateUtils.parse('2014-01-01T13:13:34.441Z')?.toJSON();
-    expect(d1).toBe('2014-01-01T13:13:34.441Z');
+test("Tests for parse", () => {
+  const d1 = DateUtils.parse("2014-01-01T13:13:34.441Z")?.toJSON();
+  expect(d1).toBe("2014-01-01T13:13:34.441Z");
 
-    const d2 = DateUtils.parse('2024-03-01T11:41');
-    expect(d2?.getDate()).toBe(1);
-    expect(d2?.getHours()).toBe(11);
-    expect(d2?.getSeconds()).toBe(0);
+  const d2 = DateUtils.parse("2024-03-01T11:41");
+  expect(d2?.getDate()).toBe(1);
+  expect(d2?.getHours()).toBe(11);
+  expect(d2?.getSeconds()).toBe(0);
 });
 
-test('Tests for sameDay', () => {
-    expect(
-        DateUtils.sameDay('2022/9/11 22:03', new Date(2022, 8, 11, 10, 3))
-    ).toBeTruthy();
-    expect(
-        DateUtils.sameDay('2022/9/11 22:03', new Date(2022, 9, 11, 10, 3))
-    ).toBeFalsy();
+test("Tests for sameDay", () => {
+  expect(
+    DateUtils.sameDay("2022/9/11 22:03", new Date(2022, 8, 11, 10, 3))
+  ).toBeTruthy();
+  expect(
+    DateUtils.sameDay("2022/9/11 22:03", new Date(2022, 9, 11, 10, 3))
+  ).toBeFalsy();
 });
 
-test('Tests for sameMonth', () => {
-    expect(
-        DateUtils.sameMonth('2022-09-11 22:03', new Date(2022, 8, 10, 10, 3))
-    ).toBeTruthy();
-    expect(
-        DateUtils.sameMonth('2022/9/11 22:03', '2022/8/31 23:59:59')
-    ).toBeFalsy();
+test("Tests for sameMonth", () => {
+  expect(
+    DateUtils.sameMonth("2022-09-11 22:03", new Date(2022, 8, 10, 10, 3))
+  ).toBeTruthy();
+  expect(
+    DateUtils.sameMonth("2022/9/11 22:03", "2022/8/31 23:59:59")
+  ).toBeFalsy();
 });