feat: move hasInstance to enum.items

Author: shijistar

src/enum-collection.ts

@@ -52,12 +52,8 @@ export class EnumCollectionClass<
    * - **CN:** 布尔值，表示这是一个枚举集合实例
    */
   readonly [IS_ENUM] = true;
-  [Symbol.hasInstance](this: EnumCollectionClass<T, K, V>, instance: unknown): boolean {
-    // intentionally use == to support both number and string format value
-    return this.items.some(
-      // eslint-disable-next-line eqeqeq
-      (i) => instance == i.value || instance === i.key
-    );
+  [Symbol.hasInstance]<T>(instance: T): instance is Extract<T, K | V> {
+    return instance instanceof this.items;
   }
   /**
    * The enum collection name, supports localization. Note that it usually returns a string, but if

src/enum-items.ts

@@ -52,6 +52,14 @@ export class EnumItemsArray<
     super(...items);
     this.__raw__ = raw;
   }
+  name?: string | undefined;
+  [Symbol.hasInstance]<T>(instance: T): instance is Extract<T, K | V> {
+    // intentionally use == to support both number and string format value
+    return this.some(
+      // eslint-disable-next-line eqeqeq
+      (i) => (instance as unknown as V) == i.value || (instance as unknown as K) === i.key
+    );
+  }
 
   label<KV extends V | K | NonNullable<PrimitiveOf<V>> | NonNullable<PrimitiveOf<K>> | undefined>(
     keyOrValue: KV
@@ -220,6 +228,12 @@ export interface IEnumItems<
    * - **CN:** 布尔值，表示这是一个枚举项数组
    */
   [IS_ENUM_ITEMS]: true;
+  /**
+   * - **EN:** A method that determines if a constructor object recognizes an object as one of the
+   *   constructor’s instances. Called by the semantics of the `instanceof` operator.
+   * - **CN:** 一个方法，用于确定构造函数对象是否将对象识别为构造函数的实例之一。由 `instanceof` 运算符的语义调用。
+   */
+  [Symbol.hasInstance]<T>(instance: T): instance is Extract<T, K | V>;
   /**
    * - **EN:** The enum collection name, supports localization.
    *

src/enum.ts

@@ -202,12 +202,6 @@ export type IEnum<
      * - **CN:** 布尔值，表示这是一个枚举类
      */
     [IS_ENUM]: true;
-    /**
-     * - **EN:** A method that determines if a constructor object recognizes an object as one of the
-     *   constructor’s instances. Called by the semantics of the `instanceof` operator.
-     * - **CN:** 一个方法，用于确定构造函数对象是否将对象识别为构造函数的实例之一。由 `instanceof` 运算符的语义调用。
-     */
-    [Symbol.hasInstance]<T>(instance: T): instance is Extract<T, K | V>;
   } & {
     // Add enum item values, just like native enums
     [key in K]: ValueTypeFromSingleInit<T[key], key, T[K] extends number | undefined ? number : key>;

test/test-suites/enum-collection.ts

@@ -1,4 +1,4 @@
-import { defaultLocalize, IS_ENUM as IS_ENUM_IN_NODE } from '@enum-plus';
+import { IS_ENUM as IS_ENUM_IN_NODE } from '@enum-plus';
 import type TestEngineBase from '../engines/base';
 import { toPlainEnums } from '../utils/index';
 import { addEnumValuesTestSuite } from './enum-items';
@@ -135,7 +135,7 @@ const testEnumCollection = (engine: TestEngineBase) => {
         engine.expect(strangeEnum.items.toMenu()).toHaveLength(Object.keys(strangeEnumConfig).length);
         engine.expect(strangeEnum.toValueMap).toBe(5);
         const map: Record<string, { text: string | undefined }> = {};
-        Object.entries(strangeEnumConfig).forEach(([key, item]) => {
+        Object.entries(strangeEnumConfig).forEach(([, item]) => {
           map[item.value] = { text: item.label };
         });
         engine.expect(strangeEnum.items.toValueMap()).toEqual(map);
@@ -173,25 +173,18 @@ const testEnumCollection = (engine: TestEngineBase) => {
     );
 
     engine.test(
-      'enums.value/enums.key/enums.label should be applicable to "instanceof" operator',
-      ({ EnumPlus: { Enum }, WeekConfig: { StandardWeekConfig, lang, getLocales, genSillyLocalizer } }) => {
+      'Enum should be applicable to "instanceof" operator',
+      ({ EnumPlus: { Enum }, WeekConfig: { StandardWeekConfig } }) => {
         const week = Enum(StandardWeekConfig);
-        return { week, lang, getLocales, genSillyLocalizer };
+        return { week };
       },
-      ({ week, lang, getLocales, genSillyLocalizer }) => {
-        const sillyLocalize = genSillyLocalizer(lang, getLocales, defaultLocalize);
-        engine.expect((0 as unknown) instanceof (week as unknown as () => void)).toBeTruthy();
-        engine.expect(('Sunday' as unknown) instanceof (week as unknown as () => void)).toBeTruthy();
-        engine
-          .expect((sillyLocalize('weekday.sunday') as unknown) instanceof (week as unknown as () => void))
-          .toBeTruthy();
-        engine.expect((6 as unknown) instanceof (week as unknown as () => void)).toBeTruthy();
-        engine.expect(('Saturday' as unknown) instanceof (week as unknown as () => void)).toBeTruthy();
-        engine
-          .expect((sillyLocalize('weekday.saturday') as unknown) instanceof (week as unknown as () => void))
-          .toBeTruthy();
-        engine.expect((7 as unknown) instanceof (week as unknown as () => void)).toBeFalsy();
-        engine.expect(('[Not Exists]' as unknown) instanceof (week as unknown as () => void)).toBeFalsy();
+      ({ week }) => {
+        engine.expect((0 as unknown) instanceof week).toBeTruthy();
+        engine.expect(('Sunday' as unknown) instanceof week).toBeTruthy();
+        engine.expect((6 as unknown) instanceof week).toBeTruthy();
+        engine.expect(('Saturday' as unknown) instanceof week).toBeTruthy();
+        engine.expect((7 as unknown) instanceof week).toBeFalsy();
+        engine.expect(('[Not Exists]' as unknown) instanceof week).toBeFalsy();
       }
     );
   });

test/test-suites/enum-items.ts

@@ -257,6 +257,22 @@ export function addEnumValuesTestSuite(engine: TestEngineBase) {
     }
   );
 
+  engine.test(
+    'enum.items should be applicable to "instanceof" operator',
+    ({ EnumPlus: { Enum }, WeekConfig: { StandardWeekConfig } }) => {
+      const week = Enum(StandardWeekConfig);
+      return { week };
+    },
+    ({ week }) => {
+      engine.expect((0 as unknown) instanceof week.items).toBeTruthy();
+      engine.expect(('Sunday' as unknown) instanceof week.items).toBeTruthy();
+      engine.expect((6 as unknown) instanceof week.items).toBeTruthy();
+      engine.expect(('Saturday' as unknown) instanceof week.items).toBeTruthy();
+      engine.expect((7 as unknown) instanceof week.items).toBeFalsy();
+      engine.expect(('[Not Exists]' as unknown) instanceof week.items).toBeFalsy();
+    }
+  );
+
   engine.test(
     'enums.valueType should throw error when called at runtime',
     ({ EnumPlus: { Enum }, WeekConfig: { StandardWeekConfig } }) => {