@avstantso/utils-enum-class 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+
+## [1.2.1] - 2026-01-18
+
+### Changed
+
+- Fix publishing
+
 All notable changes to this project will be documented in this file.
 
 ## [1.1.0] - 2026-01-18

package/dist/_global/_register.d.ts

@@ -0,0 +1,464 @@
+/**
+ * @summary Enum implementation where every item is instance of class
+ * @example
+ * export namespace CollectionAction {
+ *   export type Item = typeof CollectionAction.Item;
+ * 
+ *   export type Signs = typeof _CollectionAction.signs;
+ *   export type SignsUnion = keyof {
+ *     [K in keyof Signs as Extract<Signs[K], string>]: 0;
+ *   };
+ * 
+ *   export type Sign<Index extends number> = Index extends keyof Signs
+ *     ? Signs[Index]
+ *     : SignsUnion;
+ * }
+ * 
+ * export class _CollectionAction<
+ *   TValue extends number = number
+ * > extends EnumClass<TValue> {
+ *   public static signs = ['+', '✎', '-', '🔥'] as const;
+ * 
+ *   public static Items = {
+ *     add: new _CollectionAction(0),
+ *     update: new _CollectionAction(1),
+ *     delete: new _CollectionAction(2),
+ *     clear: new _CollectionAction(3)
+ *   };
+ * 
+ *   private _sign: CollectionAction.Sign<TValue>;
+ * 
+ *   constructor(value: TValue) {
+ *     super(value);
+ * 
+ *     this._sign = _CollectionAction.signs[
+ *       +this
+ *     ] as CollectionAction.Sign<TValue>;
+ *   }
+ * 
+ *   public get sign() {
+ *     return this._sign;
+ *   }
+ * }
+ * 
+ * export const CollectionAction = _CollectionAction.Init();
+ * @example
+ * export namespace FileMode {
+ *   export type Item = typeof FileMode.Item;
+ * }
+ * 
+ * export class _FileMode<
+ *   TValue extends number = number
+ * > extends EnumClass<TValue> {
+ *   public static IsFlags = true as const;
+ * 
+ *   public static Items = {
+ *     read: new _FileMode(1),
+ *     write: new _FileMode(2),
+ *     readWrite: new _FileMode(3), // 👈 Predefined combination
+ *     delete: new _FileMode(4),
+ *     upload: new _FileMode(8),
+ *     download: new _FileMode(16),
+ *     append: new _FileMode(32),
+ *     zeroing: new _FileMode(64)
+ *   };
+ * }
+ * 
+ * export const FileMode = _FileMode.Init((fm) => {
+ *   const readDelete = fm.read.or.delete;
+ * 
+ *   return { readDelete };
+ * });
+ * @example
+ * export namespace Direction {
+ *   export type Item = typeof Direction.Item;
+ * }
+ * 
+ * export class _Direction<
+ *   TValue extends number = number,
+ *   TArrow extends string = string
+ * > extends EnumClass<TValue> {
+ *   static Center = class DirectionCenter<
+ *     TValue extends number = number,
+ *     TArrow extends string = string
+ *   > extends _Direction<TValue, TArrow> {
+ *     step([x, y]: [number, number]): [number, number] {
+ *       return [x, y];
+ *     }
+ *   } as typeof _Direction;
+ * 
+ *   public static ToJSONField = 'arrow';
+ * 
+ *   public static Items = {
+ *     top: new _Direction(0, '↑'),
+ *     left: new _Direction(1, '←'),
+ *     bottom: new _Direction(2, '↓'),
+ *     right: new _Direction(3, '→'),
+ *     center: new _Direction.Center(-1, '⊕')
+ *   };
+ * 
+ *   public readonly arrow: TArrow;
+ * 
+ *   constructor(value: TValue, arrow: TArrow) {
+ *     super(value);
+ *     this.arrow = arrow;
+ *   }
+ * 
+ *   step([x, y]: [number, number], d = 1): [number, number] {
+ *     return Direction.switch(this, {
+ *       top: [x, y - d],
+ *       left: [x - d, y],
+ *       bottom: [x, y + d],
+ *       right: [x + d, y]
+ *     });
+ *   }
+ * }
+ * 
+ * export const Direction = _Direction.Init();
+ */
+declare namespace AVStantso_EnumClass {
+    type KVO<TClass extends AVStantso_EnumClass.Class = AVStantso_EnumClass.Class> = AVStantso_EnumClass.KeyOrValueOrObject<TClass>;
+    export namespace Item {
+        type Name = string;
+        type Value = number;
+        type Template = {
+            readonly name: Name;
+            readonly value: Value;
+        };
+        namespace Or {
+            type Cases<TClass extends Class, TRestNames extends keyof TClass['Items'], TNames extends keyof TClass['Items']> = {
+                [K in TRestNames]: Item<TClass, TNames | K> & Next<TClass, Exclude<TRestNames, K>, TNames | K>;
+            };
+            type Next<TClass extends Class, TRestNames extends keyof TClass['Items'], TNames extends keyof TClass['Items']> = [TRestNames] extends [never] ? unknown : {
+                /**
+                   * @summary Chaining access to flags combinations
+                   */
+                or: Cases<TClass, TRestNames, TNames>;
+            };
+        }
+    }
+    export namespace Switch {
+        type Cases<TClass extends Class, TCase> = AVStantso.Switch.Cases<keyof TClass['Items'] | keyof Meta.ValuesMap<TClass>, {
+            Case: TCase;
+        }>;
+    }
+    /**
+     * @summary This is analog of switch construction supports values from type enum
+     * @example enum E {a, b, c, d, e }
+     * const x = switch<number>(E.d, {a: 1, b: 2, "c|d|e": 3, default: 4} );
+     * // x = 3
+     */
+    export type Switch<TClass extends Class> = {
+        <TCase, TCases extends Switch.Cases<TClass, TCase> = Switch.Cases<TClass, TCase>>(value: KVO, cases: TCases): TCase;
+    };
+    export type Item<TClass extends Class, TName extends keyof TClass['Items'] = keyof TClass['Items'], IsDetermined extends boolean = false> = TClass['Items'][TName] & {
+        /**
+         * @summary Name casted to `keyof TClass['Items']`
+         */
+        readonly key: TName;
+        /**
+         * @summary Prev enum item. Turns first to last
+         */
+        readonly prev: Item<TClass>;
+        /**
+         * @summary Next enum item. Turns last to first
+         */
+        readonly next: Item<TClass>;
+        /**
+         * @summary Scroll enum item `by`. Turns last to first and first to last
+         * @param by If positive: scroll up (turns last to first) / If negative: scroll down (turns first to last)
+         */
+        scroll(by?: number): Item<TClass>;
+        /**
+         * @summary Check if `other` is an enum of objects with some value. Use `tryFrom`
+         */
+        is(other: KVO<TClass>): boolean;
+        /**
+         * @summary Switch case for this enum item
+         * @see AVStantso.Switch
+         */
+        switch<TCase, TCases extends AVStantso_EnumClass.Switch.Cases<TClass, TCase> = AVStantso_EnumClass.Switch.Cases<TClass, TCase>>(cases: TCases): TCase;
+    } & (TClass['IsFlags'] extends true ? IsDetermined extends true ? Item.Or.Next<TClass, Exclude<keyof TClass['Items'], TName>, TName> : unknown : unknown);
+    export type Class = {
+        new <TValue extends number = number>(value: TValue, ...params: AVStantso.TS.Arr): AVStantso_EnumClass<TValue>;
+        /**
+         * @summary Design time only. Type source of Enum.Meta.Statics
+         * @description All public statics must be declared as type and override this property
+         * @default {}
+         */
+        Statics?: object;
+        /**
+         * @summary `true` — allow create values combinations
+         * @default false
+         */
+        IsFlags: boolean;
+        /**
+         * @summary Field name for JSON serialization
+         * @default `value`
+         */
+        ToJSONField: string;
+        /**
+         * @summary Enum items. Must be overridden in Enum child class
+         */
+        Items: NodeJS.Dict<Item.Template>;
+    };
+    export type KeyOrValueOrObject<TClass extends Class> = string | number | InstanceType<TClass>;
+    export namespace Meta {
+        type ValuesMap<TClass extends Class> = {
+            [K in keyof TClass['Items'] as TClass['Items'][K]['value']]: Item<TClass, K, true>;
+        };
+        /**
+         * @summary Get item object by name, by value or by object or `ToJSONField` field value
+         * @param candidate Input data
+         * @param defaultValue Default value for fails get
+         */
+        type From<TClass extends Class> = {
+            /**
+             * @summary Get item object by name, by value or by object or `ToJSONField` field value
+             * @param candidate Input data
+             * @param defaultValue Default value for fails get
+             */
+            (candidate: KVO<TClass>, defaultValue?: Item<TClass>): Item<TClass>;
+            /**
+             * @summary Get item object by capitalized name
+             * @param candidate Input data
+             * @param defaultValue Default value for fails get
+             */
+            capitalized(candidate: string, defaultValue?: Item<TClass>): Item<TClass>;
+            /**
+             * @summary Get item object by uncapitalized name
+             * @param candidate Input data
+             * @param defaultValue Default value for fails get
+             */
+            uncapitalized(candidate: string, defaultValue?: Item<TClass>): Item<TClass>;
+            /**
+             * @summary Get item object by case insensitive name
+             * @param candidate Input data
+             * @param defaultValue Default value for fails get
+             */
+            caseInsensitive(candidate: string, defaultValue?: Item<TClass>): Item<TClass>;
+        };
+        namespace Is {
+            namespace Or {
+                type Cases<TClass extends Class, TRestNames extends keyof TClass['Items'], TNames extends keyof TClass['Items']> = {
+                    [K in TRestNames]: {
+                        /**
+                         * @summary Check `candidate` is Enum class item instance
+                         */
+                        (candidate: unknown): candidate is Item<TClass, TNames | K>;
+                    } & Next<TClass, Exclude<TRestNames, K>, TNames | K>;
+                };
+                type Next<TClass extends Class, TRestNames extends keyof TClass['Items'], TNames extends keyof TClass['Items']> = [TRestNames] extends [never] ? unknown : {
+                    /**
+                       * @summary Chaining access to fill `is` filter.
+                       * @example
+                       * // 👇 See below: Only inline calls are supported
+                       * class _ABCD<TValue extends number = number> extends Enum<TValue> {
+                       *     public static Items = {
+                       *       A: new _ABCD(0),
+                       *       B: new _ABCD(1),
+                       *       C: new _ABCD(2),
+                       *       D: new _ABCD(3),
+                       *     };
+                       *   }
+                       *
+                       *   export const ABCD = _ABCD.Init();
+                       *
+                       *   // ✔
+                       *   console.log(ABCD.is.A.or.B(ABCD.C)); // prints: false
+                       *   console.log(ABCD.is.A.or.B(ABCD.B)); // prints: true
+                       *
+                       *   // ❌
+                       *   const or = ABCD.is.A.or;   // `or` is stateful, state: [A]
+                       *   console.log(or.B(ABCD.D)); // state: [A, B]       | prints: false
+                       *   console.log(or.C(ABCD.D)); // state: [A, B, C]    | prints: false
+                       *   console.log(or.D(ABCD.B)); // state: [A, B, C, D] | prints: true ⚠
+                       *   console.log(or.D(ABCD.C)); // state: [A, B, C, D] | prints: true ⚠
+                       */
+                    or: Cases<TClass, TRestNames, TNames>;
+                };
+            }
+            namespace String {
+                namespace Or {
+                    type Cases<TClass extends Class, TRestNames extends keyof TClass['Items'], TNames extends keyof TClass['Items']> = {
+                        [K in TRestNames]: {
+                            /**
+                             * @summary Check `candidate` is enum item name-like string
+                             */
+                            (candidate: string): boolean;
+                        } & Next<TClass, Exclude<TRestNames, K>, TNames | K>;
+                    };
+                    type Next<TClass extends Class, TRestNames extends keyof TClass['Items'], TNames extends keyof TClass['Items']> = [TRestNames] extends [never] ? unknown : {
+                        /**
+                           * @summary Chaining access to fill `is` name-like string filter.
+                           * @see AVStantso_EnumClass.Meta.Is.Or ⚠ `or` is stateful
+                           */
+                        or: Cases<TClass, TRestNames, TNames>;
+                    };
+                }
+            }
+            /**
+             * @summary Check `candidate` is enum item name-like string
+             */
+            type String<TClass extends Class> = {
+                /**
+                 * @summary Check `candidate` is enum item name-like string
+                 */
+                (candidate: string, ...filters: InstanceType<TClass>[]): boolean;
+            } & {
+                [K in keyof TClass['Items']]: {
+                    /**
+                     * @summary Check `candidate` enum item name-like string
+                     */
+                    (candidate: string): boolean;
+                } & String.Or.Next<TClass, Exclude<keyof TClass['Items'], K>, K>;
+            };
+        }
+        /**
+         * @summary Check `candidate` is Enum class instance and match to filter if it's defined
+         */
+        type Is<TClass extends Class> = {
+            /**
+             * @summary Check `candidate` is Enum class instance (+ use `tryFrom`) and match to filter if it's defined
+             */
+            (candidate: unknown, ...filters: InstanceType<TClass>[]): candidate is Item<TClass>;
+            /**
+             * @summary Check `candidate` is enum item name-like capitalized string
+             */
+            capitalized: Is.String<TClass>;
+            /**
+             * @summary Check `candidate` is enum item name-like uncapitalized string
+             */
+            uncapitalized: Is.String<TClass>;
+            /**
+             * @summary Check `candidate` is enum item name-like caseInsensitive string
+             */
+            caseInsensitive: Is.String<TClass>;
+        } & {
+            [K in keyof TClass['Items']]: {
+                /**
+                 * @summary Check `candidate` is Enum class item instance
+                 */
+                (candidate: unknown): candidate is Item<TClass>;
+            } & Is.Or.Next<TClass, Exclude<keyof TClass['Items'], K>, K>;
+        };
+    }
+    export type Meta<TClass extends Class = Class, TKey extends keyof TClass['Items'] = keyof TClass['Items']> = {
+        [K in TKey]: Item<TClass, K, true>;
+    } & Meta.ValuesMap<TClass> & {
+        /**
+         * @summary Enum class access
+         */
+        readonly enumClass: TClass;
+        /**
+         * @summary Enum class name without firsts `_`
+         */
+        readonly enumName: string;
+        /**
+         * @summary Check `candidate` is string key of enum items
+         */
+        hasKey(candidate: unknown): candidate is TKey;
+        /**
+         * @summary Design time only. May be used with `typeof` for get key item type
+         */
+        readonly Key?: TKey;
+        /**
+         * @summary Design time only. May be used with `typeof` for get common item type
+         */
+        readonly Item?: Item<TClass>;
+        /**
+         * @summary Design time only. May be used with `typeof` for get `KeyOrValueOrObject` type
+         */
+        readonly KVO?: KeyOrValueOrObject<TClass>;
+        /**
+         * @summary Array of all keys (sorted by `this.values` order). Not including flags combinations.
+         */
+        readonly keys: ReadonlyArray<TKey>;
+        /**
+         * @summary Array of all names (sorted by `this.values` order). Not including flags combinations.
+         */
+        readonly names: ReadonlyArray<string>;
+        /**
+         * @summary Array of all numbers values (sorted ascending). Not including flags combinations.
+         */
+        readonly values: ReadonlyArray<number>;
+        /**
+         * @summary Try get item object by name, by value or by object or `ToJSONField` field value
+         * @param candidate Input data
+         * @param defaultValue Default value for fails get
+         * @returns Object if found. `defaultValue` or `null` if not found
+         */
+        tryFrom: Meta.From<TClass>;
+        /**
+         * @summary Get item object by name, by value or by object or `ToJSONField` field value
+         * @param candidate Input data
+         * @param defaultValue Default value for fails get
+         * @returns Object if found. If not found: `defaultValue` if it's defined, else throws `InvalidArgumentError`
+         */
+        from: Meta.From<TClass>;
+        /**
+         * @summary Get random itemitem object by name, by value or by object
+         * @returns Object. Throws `InvalidArgumentError` if not found
+         */
+        random(): Item<TClass>;
+        /**
+         * @summary Check `candidate` is Enum class instance and match to filter if it's defined
+         */
+        is: Meta.Is<TClass>;
+        /**
+         * @summary Create mapping for enum
+         * @see AVStantso.Mapping
+         */
+        Mapping<TTemplate extends object>(template: TTemplate): AVStantso.Mapping<TClass['Items'], TTemplate, 'value'>;
+        /**
+         * @summary Switch case for enum
+         * @see AVStantso.Switch
+         */
+        switch: AVStantso_EnumClass.Switch<TClass>;
+        /**
+         * @summary Add fields to passed entity by record with enum key
+         * @param original Entity for extend
+         * @param extender Addition item by key
+         * @returns Extended entity
+         * @see AVStantso.Extend
+         */
+        Extender: AVStantso.Extend.ByRecord<TKey, Item<TClass>>;
+    } & TClass['Statics'];
+    export {};
+}
+declare class AVStantso_EnumClass<TValue extends number = number> extends AVStantso_ValueWrap<TValue> implements AVStantso_EnumClass.Item.Template {
+    #private;
+    /**
+     * @see AVStantso_EnumClass.Class.Statics
+     */
+    static Statics?: object;
+    /**
+     * @see AVStantso_EnumClass.Class.IsFlags
+     */
+    static IsFlags: boolean;
+    /**
+     * @see AVStantso_EnumClass.Class.ToJSONField
+     */
+    static ToJSONField: string;
+    /**
+     * @see AVStantso_EnumClass.Class.Items
+     */
+    static Items: object;
+    /**
+     * @summary Test `candidate` is initialized enumeration.
+     */
+    static isEnum(candidate: unknown): candidate is AVStantso_EnumClass.Meta;
+    static random<TClass extends AVStantso_EnumClass.Class>(this: TClass): InstanceType<TClass>;
+    static Init<TClass extends AVStantso_EnumClass.Class, TExtension extends (meta: AVStantso_EnumClass.Meta<TClass>) => unknown, R extends AVStantso_EnumClass.Meta<TClass> & ReturnType<TExtension> = AVStantso_EnumClass.Meta<TClass> & ReturnType<TExtension>>(this: TClass, initExt?: TExtension): {
+        [K in keyof R]: R[K];
+    };
+    /**
+     * @summary Access to `class`. ⚠ Use with caution when there is a complex hierarchy
+     */
+    protected get meta(): any;
+    private _name;
+    constructor(value: TValue);
+    get name(): string;
+    protected toString(): string;
+    protected toJSON(): any;
+}

package/dist/_global/index.d.ts

@@ -0,0 +1 @@
+import './_register';

package/dist/export.d.ts

@@ -0,0 +1,2 @@
+import EnumClass = AVStantso_EnumClass;
+export { EnumClass };

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import '@avstantso/errors';
+import '@avstantso/js';
+import '@avstantso/concepts';
+import './_global';
+export * from './export';

package/dist/index.js

@@ -0,0 +1,375 @@
+'use strict';
+
+require('@avstantso/errors');
+require('@avstantso/js');
+require('@avstantso/concepts');
+
+let AVStantso_EnumClass$1 = class AVStantso_EnumClass extends AVStantso_ValueWrap {
+    static #FROM_MODES = {
+        capitalized: 1,
+        uncapitalized: 2,
+        caseInsensitive: 3
+    };
+    //#region static implements Enum.Class
+    /**
+     * @see AVStantso_EnumClass.Class.Statics
+     */
+    static Statics;
+    /**
+     * @see AVStantso_EnumClass.Class.IsFlags
+     */
+    static IsFlags = false;
+    /**
+     * @see AVStantso_EnumClass.Class.ToJSONField
+     */
+    static ToJSONField = 'value';
+    /**
+     * @see AVStantso_EnumClass.Class.Items
+     */
+    static Items = null;
+    //#endregion
+    /**
+     * @summary Test `candidate` is initialized enumeration.
+     */
+    static isEnum(candidate) {
+        return (candidate
+            && avstantso.JS.is.function(candidate)
+            && !!candidate.enumClass);
+    }
+    static random() {
+        const { values } = this;
+        const i = Math.floor(Math.random() * values.length);
+        return this[values[i]];
+    }
+    static Init(initExt) {
+        const { JS, Switch, Extend } = avstantso;
+        const FROM_MODES = AVStantso_EnumClass.#FROM_MODES;
+        const enumClass = this;
+        const { IsFlags, ToJSONField, Items } = this;
+        const combinations = IsFlags && {};
+        const hasKey = function hasKey(candidate) {
+            return JS.is.string(candidate) && candidate in this.Items;
+        }.bind(this);
+        //#region from
+        function findFrom(candidate, mode, safe) {
+            if (undefined === candidate && safe)
+                return;
+            function badData() {
+                if (!safe)
+                    throw new AVStantso_InvalidArgumentTypeError(this, 'findFrom', [this.name, 'string', 'number'], { candidate });
+            }
+            if (undefined !== mode) {
+                if (JS.is.string(candidate)) {
+                    const [, v] = Object.entries(Items).find(([key]) => {
+                        switch (mode) {
+                            case FROM_MODES.capitalized:
+                                return (candidate.toCapitalized() === String(key).toCapitalized());
+                            case FROM_MODES.uncapitalized:
+                                return (candidate.toUncapitalized()
+                                    === String(key).toUncapitalized());
+                            case FROM_MODES.caseInsensitive:
+                                return candidate.toUpperCase() === String(key).toUpperCase();
+                            default:
+                                throw new AVStantso_InvalidArgumentError(this, 'findFrom', { mode });
+                        }
+                    }) || [];
+                    return v;
+                }
+                badData.call(this);
+            }
+            else {
+                if (JS.is.object(candidate)) {
+                    if (candidate instanceof this)
+                        return candidate;
+                }
+                else if (JS.is.number(candidate)) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const v = !Number.isNaN(candidate) && this[candidate];
+                    if (v)
+                        return v;
+                }
+                else if (JS.is.string(candidate)) {
+                    {
+                        const [, v] = Object.entries(Items).find(([key]) => candidate === key) || [];
+                        if (v)
+                            return v;
+                    }
+                    if ('value' === ToJSONField) {
+                        const n = Number.parseInt(candidate, 10);
+                        if (!Number.isNaN(n)) {
+                            const v = findFrom.call(this, n);
+                            if (v)
+                                return v;
+                        }
+                    }
+                    else {
+                        const finder = (item) => 
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        item[ToJSONField] === candidate;
+                        {
+                            const v = Object.values(Items).find(finder);
+                            if (v)
+                                return v;
+                        }
+                        if (combinations) {
+                            const v = Object.values(combinations).find(finder);
+                            if (v)
+                                return v;
+                        }
+                    }
+                }
+                else
+                    badData.call(this);
+            }
+        }
+        function doFrom(candidate, defaultValue, mode, safe) {
+            const v = findFrom.call(this, candidate, mode, safe || undefined !== defaultValue);
+            if (v)
+                return v;
+            if (!v && undefined !== defaultValue)
+                return defaultValue;
+            if (!v && safe)
+                return null;
+            // console.warn(`%O`, this);
+            throw new AVStantso_InvalidArgumentError(this, 'from', { candidate }, 'invalid enum value %FV');
+        }
+        function WrapFrom(f, safe) {
+            return Object.assign(f, {
+                capitalized: function tryFromCapitalized(candidate, defaultValue) {
+                    return doFrom.call(this, candidate, defaultValue, FROM_MODES.capitalized, safe);
+                }.bind(this),
+                uncapitalized: function tryFromUncapitalized(candidate, defaultValue) {
+                    return doFrom.call(this, candidate, defaultValue, FROM_MODES.uncapitalized, safe);
+                }.bind(this),
+                caseInsensitive: function tryFromCaseInsensitive(candidate, defaultValue) {
+                    return doFrom.call(this, candidate, defaultValue, FROM_MODES.caseInsensitive, safe);
+                }.bind(this)
+            });
+        }
+        const tryFrom = WrapFrom.call(this, function tryFrom(candidate, defaultValue) {
+            return doFrom.call(this, candidate, defaultValue, undefined, true);
+        }.bind(this), true);
+        const from = WrapFrom.call(this, function from(candidate, defaultValue) {
+            return doFrom.call(this, candidate, defaultValue);
+        }.bind(this));
+        //#endregion
+        const toName = (value) => tryFrom(value)?.name;
+        const _switch = Switch(toName);
+        const Mapping = avstantso.Mapping('value', toName);
+        const Extender = Extend.ByRecord(Object.keys(Items), from);
+        function IsEnumItem(mode) {
+            return Extender(function isEnumItem(candidate, ...filters) {
+                const obj = doFrom.call(this, candidate, undefined, mode, true);
+                if (obj) {
+                    if (!filters.length)
+                        return true;
+                    const v = +obj;
+                    for (const f of filters)
+                        if (+f === v)
+                            return true;
+                }
+                return false;
+            }.bind(this), function (item, original) {
+                const filters = new Set([item]);
+                const isOr = function isOr(candidate) {
+                    return original.call(this, candidate, ...filters);
+                }.bind(this);
+                const proxy = new Proxy(isOr, {
+                    get(target, p) {
+                        if (hasKey(p)) {
+                            filters.add(from(p));
+                            return isOr;
+                        }
+                        return Reflect.get(target, p);
+                    }
+                });
+                Object.defineProperties(isOr, {
+                    or: { value: proxy, writable: false }
+                });
+                return proxy;
+            });
+        }
+        const isEnumItem = Object.assign(IsEnumItem.call(this), {
+            capitalized: IsEnumItem.call(this, FROM_MODES.capitalized),
+            uncapitalized: IsEnumItem.call(this, FROM_MODES.uncapitalized),
+            caseInsensitive: IsEnumItem.call(this, FROM_MODES.caseInsensitive)
+        });
+        // Protect from runtime access. Will redefine as property
+        delete this.Statics;
+        const designtimeOnly = {
+            value: undefined,
+            writable: false,
+            configurable: false
+        };
+        Object.defineProperties(this, {
+            Statics: designtimeOnly,
+            Key: designtimeOnly,
+            Item: designtimeOnly,
+            KVO: designtimeOnly,
+            enumClass: { value: enumClass, writable: false },
+            enumName: { value: this.name.replace(/$_+/, ''), writable: false },
+            hasKey: { value: hasKey, writable: false },
+            map: { value: Items, writable: false },
+            ...(combinations
+                ? { combinations: { value: combinations, writable: false } }
+                : {}),
+            tryFrom: { value: tryFrom, writable: false },
+            from: { value: from, writable: false },
+            is: { value: isEnumItem, writable: false },
+            switch: { value: _switch, writable: false },
+            Mapping: { value: Mapping, writable: false },
+            Extender: { value: Extender, writable: false }
+        });
+        function add(item, name) {
+            function is(other) {
+                const obj = tryFrom(other);
+                return obj && +this === +obj;
+            }
+            function scroll(by = 1) {
+                if (0 === by)
+                    return this;
+                const { value } = this;
+                AVStantso_InvalidArgumentTypeError.validate.number(this, scroll, { by });
+                const { values } = enumClass;
+                const lastI = values.length - 1;
+                const step = Math.sign(by);
+                let i = values.findIndex((ind) => ind === value);
+                for (let j = Math.abs(by % values.length); j > 0; j--) {
+                    if (i <= 0)
+                        i = lastI;
+                    else if (i >= lastI)
+                        i = 0;
+                    else
+                        i += step;
+                }
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                return enumClass[values[i]];
+            }
+            Object.assign(item, { _name: name, scroll, is });
+            Object.defineProperties(item, {
+                key: { value: name, writable: false },
+                prev: {
+                    get() {
+                        this.scroll(-1);
+                    }
+                },
+                next: {
+                    get() {
+                        this.scroll(1);
+                    }
+                },
+                switch: {
+                    value: _switch.bind(null, item.value),
+                    writable: false
+                },
+                ...(!IsFlags
+                    ? {}
+                    : {
+                        /**
+                         * @see AVStantso_EnumClass.Item.Or
+                         */
+                        or: {
+                            value: new Proxy(item, {
+                                get(target, p) {
+                                    if (hasKey(p)) {
+                                        const next = from(p);
+                                        // eslint-disable-next-line no-bitwise
+                                        return from(+target | +next);
+                                    }
+                                    return Reflect.get(target, p);
+                                }
+                            }),
+                            writable: false
+                        }
+                    })
+            });
+            for (const k of [name, item.value])
+                Object.defineProperty(this, k, { value: item, writable: false });
+            return Object.freeze(item);
+        }
+        for (const [k, v] of Object.entries(Items))
+            add.call(this, v, k);
+        if (IsFlags) {
+            function isPowerOfTwo(n) {
+                if (n == 0)
+                    return false;
+                const r = Math.log(n) / Math.log(2);
+                return Math.ceil(r) === Math.floor(r);
+            }
+            const vs = Object.values(Items)
+                .filter((v) => isPowerOfTwo(+v)) // 👈 Exclude predefined combinations
+                .sort((a, b) => +a - +b);
+            /* eslint-disable no-bitwise */
+            for (let i = 0; i < 1 << vs.length; i++) {
+                const combination = [];
+                for (let j = 0; j < vs.length; j++)
+                    if (i & (1 << j))
+                        combination.push(vs[j]);
+                if (combination.length <= 1)
+                    continue;
+                const v = combination.reduce((r, item) => r + +item, 0);
+                let c = enumClass[v];
+                if (!c) {
+                    const n = combination.map(({ name }) => name).join('|');
+                    c = add.call(this, new this(v), n);
+                }
+                combinations[c.name] = c;
+            }
+            /* eslint-enable no-bitwise */
+            Object.freeze(combinations);
+            for (const n of Object.keys(combinations))
+                delete Items[n]; // 👈 Transfer predefined combinations from Items
+        }
+        // After transfer predefined combinations
+        {
+            const values = Object.freeze(Object.values(Items)
+                .map(({ value }) => value)
+                .sort((a, b) => a - b));
+            // Sorted by `this.values` order!
+            const names = Object.freeze(values.map((v) => from(v).name));
+            Object.defineProperties(this, {
+                keys: { value: names, writable: false },
+                names: { value: names, writable: false },
+                values: { value: values, writable: false }
+            });
+        }
+        Object.freeze(Items);
+        return Object.assign(enumClass, initExt && initExt(enumClass)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        );
+    }
+    /**
+     * @summary Access to `class`. ⚠ Use with caution when there is a complex hierarchy
+     */
+    get meta() {
+        return Object.getPrototypeOf(this).constructor;
+    }
+    _name;
+    constructor(value) {
+        super(value);
+    }
+    get name() {
+        return this._name;
+    }
+    toString() {
+        return this.name;
+    }
+    toJSON() {
+        const { ToJSONField } = this.meta;
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return this[ToJSONField];
+    }
+};
+if (!('AVStantso_EnumClass' in globalThis))
+    Object.defineProperties(globalThis, {
+        AVStantso_EnumClass: {
+            value: AVStantso_EnumClass$1,
+            writable: false,
+            configurable: false
+        }
+    });
+
+var EnumClass = AVStantso_EnumClass;
+
+exports.EnumClass = EnumClass;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/_global/_register.ts","../src/export.ts"],"sourcesContent":["/**\n * @summary Enum implementation where every item is instance of class\n * @EXAMPLE(@EnumClass.CollectionAction)\n * @EXAMPLE(@EnumClass.FileMode)\n * @EXAMPLE(@EnumClass.Direction)\n */\nnamespace AVStantso_EnumClass {\n  type KVO<TClass extends AVStantso_EnumClass.Class = AVStantso_EnumClass.Class> =\n    AVStantso_EnumClass.KeyOrValueOrObject<TClass>;\n\n  //#region Item\n  export namespace Item {\n    export type Name = string;\n    export type Value = number;\n\n    export type Template = {\n      readonly name: Name;\n      readonly value: Value;\n    };\n\n    export namespace Or {\n      export type Cases<\n        TClass extends Class,\n        TRestNames extends keyof TClass['Items'],\n        TNames extends keyof TClass['Items']\n      > = {\n        [K in TRestNames]: Item<TClass, TNames | K>\n          & Next<TClass, Exclude<TRestNames, K>, TNames | K>;\n      };\n\n      export type Next<\n        TClass extends Class,\n        TRestNames extends keyof TClass['Items'],\n        TNames extends keyof TClass['Items']\n      > = [TRestNames] extends [never]\n        ? unknown\n        : {\n          /**\n             * @summary Chaining access to flags combinations\n             */\n          or: Cases<TClass, TRestNames, TNames>;\n        };\n    }\n  }\n\n  export namespace Switch {\n    export type Cases<TClass extends Class, TCase> = AVStantso.Switch.Cases<\n      keyof TClass['Items'] | keyof Meta.ValuesMap<TClass>,\n      { Case: TCase }\n    >;\n  }\n\n  /**\n   * @summary This is analog of switch construction supports values from type enum\n   * @example enum E {a, b, c, d, e }\n   * const x = switch<number>(E.d, {a: 1, b: 2, \"c|d|e\": 3, default: 4} );\n   * // x = 3\n   */\n  export type Switch<TClass extends Class> = {\n    <\n      TCase,\n      TCases extends Switch.Cases<TClass, TCase> = Switch.Cases<TClass, TCase>\n    >(\n      value: KVO,\n      cases: TCases\n    ): TCase;\n  };\n\n  export type Item<\n    TClass extends Class,\n    TName extends keyof TClass['Items'] = keyof TClass['Items'],\n    IsDetermined extends boolean = false\n  > = TClass['Items'][TName] & {\n    /**\n     * @summary Name casted to `keyof TClass['Items']`\n     */\n    readonly key: TName;\n\n    /**\n     * @summary Prev enum item. Turns first to last\n     */\n    readonly prev: Item<TClass>;\n\n    /**\n     * @summary Next enum item. Turns last to first\n     */\n    readonly next: Item<TClass>;\n\n    /**\n     * @summary Scroll enum item `by`. Turns last to first and first to last\n     * @param by If positive: scroll up (turns last to first) / If negative: scroll down (turns first to last)\n     */\n    scroll(by?: number): Item<TClass>;\n\n    /**\n     * @summary Check if `other` is an enum of objects with some value. Use `tryFrom`\n     */\n    is(other: KVO<TClass>): boolean;\n\n    /**\n     * @summary Switch case for this enum item\n     * @see AVStantso.Switch\n     */\n    switch<\n      TCase,\n      TCases extends AVStantso_EnumClass.Switch.Cases<TClass, TCase> =\n      AVStantso_EnumClass.Switch.Cases<\n        TClass,\n        TCase\n      >\n    >(\n      cases: TCases\n    ): TCase;\n  } & (TClass['IsFlags'] extends true\n    ? IsDetermined extends true\n      ? Item.Or.Next<TClass, Exclude<keyof TClass['Items'], TName>, TName>\n      : unknown\n    : unknown);\n  //#endregion\n\n  export type Class = {\n    new <TValue extends number = number>(\n      value: TValue,\n      ...params: AVStantso.TS.Arr\n    ): AVStantso_EnumClass<TValue>;\n\n    /**\n     * @summary Design time only. Type source of Enum.Meta.Statics\n     * @description All public statics must be declared as type and override this property\n     * @default {}\n     */\n    Statics?: object;\n\n    /**\n     * @summary `true` — allow create values combinations\n     * @default false\n     */\n    IsFlags: boolean;\n\n    /**\n     * @summary Field name for JSON serialization\n     * @default `value`\n     */\n    ToJSONField: string;\n\n    /**\n     * @summary Enum items. Must be overridden in Enum child class\n     */\n    Items: NodeJS.Dict<Item.Template>;\n  };\n\n  export type KeyOrValueOrObject<TClass extends Class> =\n    | string\n    | number\n    | InstanceType<TClass>;\n\n  //#region Meta\n  export namespace Meta {\n    export type ValuesMap<TClass extends Class> = {\n      [K in keyof TClass['Items'] as TClass['Items'][K]['value']]: Item<\n        TClass,\n        K,\n        true\n      >;\n    };\n\n    /**\n     * @summary Get item object by name, by value or by object or `ToJSONField` field value\n     * @param candidate Input data\n     * @param defaultValue Default value for fails get\n     */\n    export type From<TClass extends Class> = {\n      /**\n       * @summary Get item object by name, by value or by object or `ToJSONField` field value\n       * @param candidate Input data\n       * @param defaultValue Default value for fails get\n       */\n      (candidate: KVO<TClass>, defaultValue?: Item<TClass>): Item<TClass>;\n\n      /**\n       * @summary Get item object by capitalized name\n       * @param candidate Input data\n       * @param defaultValue Default value for fails get\n       */\n      capitalized(candidate: string, defaultValue?: Item<TClass>): Item<TClass>;\n\n      /**\n       * @summary Get item object by uncapitalized name\n       * @param candidate Input data\n       * @param defaultValue Default value for fails get\n       */\n      uncapitalized(\n        candidate: string,\n        defaultValue?: Item<TClass>\n      ): Item<TClass>;\n\n      /**\n       * @summary Get item object by case insensitive name\n       * @param candidate Input data\n       * @param defaultValue Default value for fails get\n       */\n      caseInsensitive(\n        candidate: string,\n        defaultValue?: Item<TClass>\n      ): Item<TClass>;\n    };\n\n    export namespace Is {\n      export namespace Or {\n        export type Cases<\n          TClass extends Class,\n          TRestNames extends keyof TClass['Items'],\n          TNames extends keyof TClass['Items']\n        > = {\n          [K in TRestNames]: {\n            /**\n             * @summary Check `candidate` is Enum class item instance\n             */\n            (candidate: unknown): candidate is Item<TClass, TNames | K>;\n          } & Next<TClass, Exclude<TRestNames, K>, TNames | K>;\n        };\n\n        export type Next<\n          TClass extends Class,\n          TRestNames extends keyof TClass['Items'],\n          TNames extends keyof TClass['Items']\n        > = [TRestNames] extends [never]\n          ? unknown\n          : {\n            /**\n               * @summary Chaining access to fill `is` filter.\n               * @example\n               * // 👇 See below: Only inline calls are supported\n               * class _ABCD<TValue extends number = number> extends Enum<TValue> {\n               *     public static Items = {\n               *       A: new _ABCD(0),\n               *       B: new _ABCD(1),\n               *       C: new _ABCD(2),\n               *       D: new _ABCD(3),\n               *     };\n               *   }\n               *\n               *   export const ABCD = _ABCD.Init();\n               *\n               *   // ✔\n               *   console.log(ABCD.is.A.or.B(ABCD.C)); // prints: false\n               *   console.log(ABCD.is.A.or.B(ABCD.B)); // prints: true\n               *\n               *   // ❌\n               *   const or = ABCD.is.A.or;   // `or` is stateful, state: [A]\n               *   console.log(or.B(ABCD.D)); // state: [A, B]       | prints: false\n               *   console.log(or.C(ABCD.D)); // state: [A, B, C]    | prints: false\n               *   console.log(or.D(ABCD.B)); // state: [A, B, C, D] | prints: true ⚠\n               *   console.log(or.D(ABCD.C)); // state: [A, B, C, D] | prints: true ⚠\n               */\n            or: Cases<TClass, TRestNames, TNames>;\n          };\n      }\n\n      export namespace String {\n        export namespace Or {\n          export type Cases<\n            TClass extends Class,\n            TRestNames extends keyof TClass['Items'],\n            TNames extends keyof TClass['Items']\n          > = {\n            [K in TRestNames]: {\n              /**\n               * @summary Check `candidate` is enum item name-like string\n               */\n              (candidate: string): boolean;\n            } & Next<TClass, Exclude<TRestNames, K>, TNames | K>;\n          };\n\n          export type Next<\n            TClass extends Class,\n            TRestNames extends keyof TClass['Items'],\n            TNames extends keyof TClass['Items']\n          > = [TRestNames] extends [never]\n            ? unknown\n            : {\n              /**\n                 * @summary Chaining access to fill `is` name-like string filter.\n                 * @see AVStantso_EnumClass.Meta.Is.Or ⚠ `or` is stateful\n                 */\n              or: Cases<TClass, TRestNames, TNames>;\n            };\n        }\n      }\n\n      /**\n       * @summary Check `candidate` is enum item name-like string\n       */\n      export type String<TClass extends Class> = {\n        /**\n         * @summary Check `candidate` is enum item name-like string\n         */\n        (candidate: string, ...filters: InstanceType<TClass>[]): boolean;\n      } & {\n        /**\n         * @summary Check `candidate` is enum item name-like string\n         */\n        [K in keyof TClass['Items']]: {\n          /**\n           * @summary Check `candidate` enum item name-like string\n           */\n          (candidate: string): boolean;\n        } & String.Or.Next<TClass, Exclude<keyof TClass['Items'], K>, K>;\n      };\n    }\n\n    /**\n     * @summary Check `candidate` is Enum class instance and match to filter if it's defined\n     */\n    export type Is<TClass extends Class> = {\n      /**\n       * @summary Check `candidate` is Enum class instance (+ use `tryFrom`) and match to filter if it's defined\n       */\n      (\n        candidate: unknown,\n        ...filters: InstanceType<TClass>[]\n      ): candidate is Item<TClass>;\n\n      /**\n       * @summary Check `candidate` is enum item name-like capitalized string\n       */\n      capitalized: Is.String<TClass>;\n\n      /**\n       * @summary Check `candidate` is enum item name-like uncapitalized string\n       */\n      uncapitalized: Is.String<TClass>;\n\n      /**\n       * @summary Check `candidate` is enum item name-like caseInsensitive string\n       */\n      caseInsensitive: Is.String<TClass>;\n    } & {\n      /**\n       * @summary Check `candidate` is Enum class item instance\n       */\n      [K in keyof TClass['Items']]: {\n        /**\n         * @summary Check `candidate` is Enum class item instance\n         */\n        (candidate: unknown): candidate is Item<TClass>;\n      } & Is.Or.Next<TClass, Exclude<keyof TClass['Items'], K>, K>;\n    };\n  }\n\n  export type Meta<\n    TClass extends Class = Class,\n    TKey extends keyof TClass['Items'] = keyof TClass['Items']\n  > = {\n    [K in TKey]: Item<TClass, K, true>;\n  } & Meta.ValuesMap<TClass> & {\n    /**\n     * @summary Enum class access\n     */\n    readonly enumClass: TClass;\n\n    /**\n     * @summary Enum class name without firsts `_`\n     */\n    readonly enumName: string;\n\n    /**\n     * @summary Check `candidate` is string key of enum items\n     */\n    hasKey(candidate: unknown): candidate is TKey;\n\n    /**\n     * @summary Design time only. May be used with `typeof` for get key item type\n     */\n    readonly Key?: TKey;\n\n    /**\n     * @summary Design time only. May be used with `typeof` for get common item type\n     */\n    readonly Item?: Item<TClass>;\n\n    /**\n     * @summary Design time only. May be used with `typeof` for get `KeyOrValueOrObject` type\n     */\n    readonly KVO?: KeyOrValueOrObject<TClass>;\n\n    /**\n     * @summary Array of all keys (sorted by `this.values` order). Not including flags combinations.\n     */\n    readonly keys: ReadonlyArray<TKey>;\n\n    /**\n     * @summary Array of all names (sorted by `this.values` order). Not including flags combinations.\n     */\n    readonly names: ReadonlyArray<string>;\n\n    /**\n     * @summary Array of all numbers values (sorted ascending). Not including flags combinations.\n     */\n    readonly values: ReadonlyArray<number>;\n\n    /**\n     * @summary Try get item object by name, by value or by object or `ToJSONField` field value\n     * @param candidate Input data\n     * @param defaultValue Default value for fails get\n     * @returns Object if found. `defaultValue` or `null` if not found\n     */\n    tryFrom: Meta.From<TClass>;\n\n    /**\n     * @summary Get item object by name, by value or by object or `ToJSONField` field value\n     * @param candidate Input data\n     * @param defaultValue Default value for fails get\n     * @returns Object if found. If not found: `defaultValue` if it's defined, else throws `InvalidArgumentError`\n     */\n    from: Meta.From<TClass>;\n\n    /**\n     * @summary Get random itemitem object by name, by value or by object\n     * @returns Object. Throws `InvalidArgumentError` if not found\n     */\n    random(): Item<TClass>;\n\n    /**\n     * @summary Check `candidate` is Enum class instance and match to filter if it's defined\n     */\n    is: Meta.Is<TClass>;\n\n    /**\n     * @summary Create mapping for enum\n     * @see AVStantso.Mapping\n     */\n    Mapping<TTemplate extends object>(\n      template: TTemplate\n    ): AVStantso.Mapping<TClass['Items'], TTemplate, 'value'>;\n\n    /**\n     * @summary Switch case for enum\n     * @see AVStantso.Switch\n     */\n    switch: AVStantso_EnumClass.Switch<TClass>;\n\n    /**\n     * @summary Add fields to passed entity by record with enum key\n     * @param original Entity for extend\n     * @param extender Addition item by key\n     * @returns Extended entity\n     * @see AVStantso.Extend\n     */\n    Extender: AVStantso.Extend.ByRecord<TKey, Item<TClass>>;\n  } & TClass['Statics'];\n  //#endregion\n}\n\nclass AVStantso_EnumClass<TValue extends number = number>\n  extends AVStantso_ValueWrap<TValue>\n  implements AVStantso_EnumClass.Item.Template\n{\n  static #FROM_MODES = {\n    capitalized: 1,\n    uncapitalized: 2,\n    caseInsensitive: 3\n  } as const;\n\n  //#region static implements Enum.Class\n  /**\n   * @see AVStantso_EnumClass.Class.Statics\n   */\n  public static Statics?: object;\n\n  /**\n   * @see AVStantso_EnumClass.Class.IsFlags\n   */\n  public static IsFlags: boolean = false;\n\n  /**\n   * @see AVStantso_EnumClass.Class.ToJSONField\n   */\n  public static ToJSONField = 'value';\n\n  /**\n   * @see AVStantso_EnumClass.Class.Items\n   */\n  public static Items: object = null;\n  //#endregion\n\n  /**\n   * @summary Test `candidate` is initialized enumeration.\n   */\n  public static isEnum(candidate: unknown): candidate is AVStantso_EnumClass.Meta {\n    return (\n      candidate\n      && avstantso.JS.is.function(candidate)\n      && !!(candidate as unknown as AVStantso_EnumClass.Meta).enumClass\n    );\n  }\n\n  public static random<TClass extends AVStantso_EnumClass.Class>(\n    this: TClass\n  ): InstanceType<TClass> {\n    const { values } = this as unknown as AVStantso_EnumClass.Meta<TClass>;\n\n    const i = Math.floor(Math.random() * values.length);\n    return (this as unknown as NodeJS.Dict<InstanceType<TClass>>)[values[i]];\n  }\n\n  public static Init<\n    TClass extends AVStantso_EnumClass.Class,\n    TExtension extends (meta: AVStantso_EnumClass.Meta<TClass>) => unknown,\n    R extends AVStantso_EnumClass.Meta<TClass> & ReturnType<TExtension> =\n    AVStantso_EnumClass.Meta<TClass> & ReturnType<TExtension>\n  >(this: TClass, initExt?: TExtension): { [K in keyof R]: R[K] } {\n    const { JS, Switch, Extend } = avstantso;\n\n    type KVO<TClass extends AVStantso_EnumClass.Class = AVStantso_EnumClass.Class> =\n      AVStantso_EnumClass.KeyOrValueOrObject<TClass>;\n\n    type TEnum = InstanceType<TClass>;\n    const FROM_MODES = AVStantso_EnumClass.#FROM_MODES;\n\n    const enumClass = this as AVStantso_EnumClass.Meta<TClass>;\n    const { IsFlags, ToJSONField, Items } = this;\n\n    const combinations: NodeJS.Dict<AVStantso_EnumClass.Item.Template> = IsFlags && {};\n\n    const hasKey = function hasKey(\n      this: TClass,\n      candidate: unknown\n    ): candidate is keyof TClass['Items'] {\n      return JS.is.string(candidate) && candidate in this.Items;\n    }.bind(this) as AVStantso_EnumClass.Meta<TClass>['hasKey'];\n\n    //#region from\n    function findFrom(\n      this: TClass,\n      candidate: unknown,\n      mode?: number,\n      safe?: boolean\n    ): AVStantso_EnumClass.Item.Template {\n      if (undefined === candidate && safe) return;\n\n      function badData(this: TClass) {\n        if (!safe)\n          throw new AVStantso_InvalidArgumentTypeError(\n            this,\n            'findFrom',\n            [this.name, 'string', 'number'],\n            { candidate }\n          );\n      }\n\n      if (undefined !== mode) {\n        if (JS.is.string(candidate)) {\n          const [, v] =\n            Object.entries(Items).find(([key]) => {\n              switch (mode) {\n                case FROM_MODES.capitalized:\n                  return (\n                    candidate.toCapitalized() === String(key).toCapitalized()\n                  );\n\n                case FROM_MODES.uncapitalized:\n                  return (\n                    candidate.toUncapitalized()\n                    === String(key).toUncapitalized()\n                  );\n\n                case FROM_MODES.caseInsensitive:\n                  return candidate.toUpperCase() === String(key).toUpperCase();\n\n                default:\n                  throw new AVStantso_InvalidArgumentError(this, 'findFrom', { mode });\n              }\n            }) || [];\n\n          return v;\n        }\n\n        badData.call(this);\n      } else {\n        if (JS.is.object(candidate)) {\n          if (candidate instanceof this) return candidate;\n        } else if (JS.is.number(candidate)) {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          const v = !Number.isNaN(candidate) && (this as any)[candidate];\n          if (v) return v;\n        } else if (JS.is.string(candidate)) {\n          {\n            const [, v] =\n              Object.entries(Items).find(([key]) => candidate === key) || [];\n\n            if (v) return v;\n          }\n\n          if ('value' === ToJSONField) {\n            const n = Number.parseInt(candidate, 10);\n            if (!Number.isNaN(n)) {\n              const v = findFrom.call(this, n);\n              if (v) return v;\n            }\n          } else {\n            const finder = (item: AVStantso_EnumClass.Item.Template) =>\n              // eslint-disable-next-line @typescript-eslint/no-explicit-any\n              (item as any)[ToJSONField] === candidate;\n\n            {\n              const v = Object.values(Items).find(finder);\n              if (v) return v;\n            }\n\n            if (combinations) {\n              const v = Object.values(combinations).find(finder);\n              if (v) return v;\n            }\n          }\n        } else badData.call(this);\n      }\n    }\n\n    function doFrom(\n      this: TClass,\n      candidate: unknown,\n      defaultValue: AVStantso_EnumClass.Item.Template,\n      mode?: number,\n      safe?: boolean\n    ): AVStantso_EnumClass.Item.Template {\n      const v = findFrom.call(\n        this,\n        candidate,\n        mode,\n        safe || undefined !== defaultValue\n      );\n      if (v) return v;\n\n      if (!v && undefined !== defaultValue) return defaultValue;\n\n      if (!v && safe) return null;\n\n      // console.warn(`%O`, this);\n      throw new AVStantso_InvalidArgumentError(\n        this,\n        'from',\n        { candidate },\n        'invalid enum value %FV'\n      );\n    }\n\n    function WrapFrom(\n      this: TClass,\n      f: (\n        candidate: KVO<TClass>,\n        defaultValue?: AVStantso_EnumClass.Item.Template\n      ) => AVStantso_EnumClass.Item.Template,\n      safe?: boolean\n    ) {\n      return Object.assign(f, {\n        capitalized: function tryFromCapitalized(\n          this: TClass,\n          candidate: string,\n          defaultValue?: AVStantso_EnumClass.Item.Template\n        ) {\n          return doFrom.call(\n            this,\n            candidate,\n            defaultValue,\n            FROM_MODES.capitalized,\n            safe\n          );\n        }.bind(this),\n\n        uncapitalized: function tryFromUncapitalized(\n          this: TClass,\n          candidate: string,\n          defaultValue?: AVStantso_EnumClass.Item.Template\n        ) {\n          return doFrom.call(\n            this,\n            candidate,\n            defaultValue,\n            FROM_MODES.uncapitalized,\n            safe\n          );\n        }.bind(this),\n\n        caseInsensitive: function tryFromCaseInsensitive(\n          this: TClass,\n          candidate: string,\n          defaultValue?: AVStantso_EnumClass.Item.Template\n        ) {\n          return doFrom.call(\n            this,\n            candidate,\n            defaultValue,\n            FROM_MODES.caseInsensitive,\n            safe\n          );\n        }.bind(this)\n      });\n    }\n\n    const tryFrom = WrapFrom.call(\n      this,\n      function tryFrom(\n        this: TClass,\n        candidate: KVO<TClass>,\n        defaultValue?: AVStantso_EnumClass.Item.Template\n      ) {\n        return doFrom.call(this, candidate, defaultValue, undefined, true);\n      }.bind(this),\n      true\n    );\n\n    const from = WrapFrom.call(\n      this,\n      function from(\n        this: TClass,\n        candidate: KVO<TClass>,\n        defaultValue?: AVStantso_EnumClass.Item.Template\n      ) {\n        return doFrom.call(this, candidate, defaultValue);\n      }.bind(this)\n    );\n    //#endregion\n\n    const toName = (value: unknown) => tryFrom(value as KVO<TClass>)?.name;\n    const _switch = Switch(toName);\n    const Mapping = avstantso.Mapping('value', toName);\n    const Extender = Extend.ByRecord(Object.keys(Items), from);\n\n    function IsEnumItem(this: TClass, mode?: number) {\n      return Extender(\n        function isEnumItem(\n          this: TClass,\n          candidate: unknown,\n          ...filters: AVStantso_EnumClass.Item.Template[]\n        ): boolean {\n          const obj = doFrom.call(this, candidate, undefined, mode, true);\n          if (obj) {\n            if (!filters.length) return true;\n\n            const v = +obj;\n            for (const f of filters) if (+f === v) return true;\n          }\n\n          return false;\n        }.bind(this),\n        function (this: TClass, item, original) {\n          const filters = new Set<AVStantso_EnumClass.Item.Template>([item]);\n\n          const isOr = function isOr(this: TClass, candidate: unknown) {\n            return original.call(this, candidate, ...filters);\n          }.bind(this);\n\n          const proxy = new Proxy(isOr, {\n            get(target, p) {\n              if (hasKey(p)) {\n                filters.add(from(p));\n                return isOr;\n              }\n\n              return Reflect.get(target, p);\n            }\n          });\n\n          Object.defineProperties(isOr, {\n            or: { value: proxy, writable: false }\n          });\n\n          return proxy;\n        }\n      );\n    }\n\n    const isEnumItem = Object.assign(IsEnumItem.call(this), {\n      capitalized: IsEnumItem.call(this, FROM_MODES.capitalized),\n      uncapitalized: IsEnumItem.call(this, FROM_MODES.uncapitalized),\n      caseInsensitive: IsEnumItem.call(this, FROM_MODES.caseInsensitive)\n    });\n\n    // Protect from runtime access. Will redefine as property\n    delete this.Statics;\n    const designtimeOnly = {\n      value: undefined as unknown,\n      writable: false,\n      configurable: false\n    };\n\n    Object.defineProperties(this, {\n      Statics: designtimeOnly,\n      Key: designtimeOnly,\n      Item: designtimeOnly,\n      KVO: designtimeOnly,\n\n      enumClass: { value: enumClass, writable: false },\n      enumName: { value: this.name.replace(/$_+/, ''), writable: false },\n      hasKey: { value: hasKey, writable: false },\n\n      map: { value: Items, writable: false },\n      ...(combinations\n        ? { combinations: { value: combinations, writable: false } }\n        : {}),\n\n      tryFrom: { value: tryFrom, writable: false },\n      from: { value: from, writable: false },\n\n      is: { value: isEnumItem, writable: false },\n\n      switch: { value: _switch, writable: false },\n      Mapping: { value: Mapping, writable: false },\n      Extender: { value: Extender, writable: false }\n    });\n\n    function add(this: TClass, item: AVStantso_EnumClass.Item.Template, name: string) {\n      function is(this: TEnum, other: KVO<TClass>): boolean {\n        const obj = tryFrom(other);\n        return obj && +this === +obj;\n      }\n\n      function scroll(this: TEnum, by = 1): TEnum {\n        if (0 === by) return this;\n\n        const { value } = this;\n\n        AVStantso_InvalidArgumentTypeError.validate.number(this, scroll, { by });\n        const { values } = enumClass;\n\n        const lastI = values.length - 1;\n        const step = Math.sign(by);\n\n        let i = values.findIndex((ind: number) => ind === value);\n        for (let j = Math.abs(by % values.length); j > 0; j--) {\n          if (i <= 0) i = lastI;\n          else if (i >= lastI) i = 0;\n          else i += step;\n        }\n\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return (enumClass as any)[values[i]];\n      }\n\n      Object.assign(item, { _name: name, scroll, is });\n\n      Object.defineProperties(item, {\n        key: { value: name, writable: false },\n        prev: {\n          get() {\n            this.scroll(-1);\n          }\n        },\n        next: {\n          get() {\n            this.scroll(+1);\n          }\n        },\n        switch: {\n          value: _switch.bind(null, item.value),\n          writable: false\n        },\n        ...(!IsFlags\n          ? {}\n          : {\n            /**\n             * @see AVStantso_EnumClass.Item.Or\n             */\n            or: {\n              value: new Proxy(item, {\n                get(target, p) {\n                  if (hasKey(p)) {\n                    const next = from(p);\n                    // eslint-disable-next-line no-bitwise\n                    return from(+target | +next);\n                  }\n\n                  return Reflect.get(target, p);\n                }\n              }),\n              writable: false\n            }\n          })\n      });\n\n      for (const k of [name, item.value])\n        Object.defineProperty(this, k, { value: item, writable: false });\n\n      return Object.freeze(item);\n    }\n\n    for (const [k, v] of Object.entries(Items)) add.call(this, v, k);\n\n    if (IsFlags) {\n      function isPowerOfTwo(n: number) {\n        if (n == 0) return false;\n\n        const r = Math.log(n) / Math.log(2);\n        return Math.ceil(r) === Math.floor(r);\n      }\n\n      const vs = Object.values(Items)\n        .filter((v) => isPowerOfTwo(+v)) // 👈 Exclude predefined combinations\n        .sort((a, b) => +a - +b);\n\n      /* eslint-disable no-bitwise */\n      for (let i = 0; i < 1 << vs.length; i++) {\n        const combination: AVStantso_EnumClass.Item.Template[] = [];\n        for (let j = 0; j < vs.length; j++)\n          if (i & (1 << j)) combination.push(vs[j]);\n\n        if (combination.length <= 1) continue;\n\n        const v = combination.reduce((r, item) => r + +item, 0);\n        let c: AVStantso_EnumClass.Item.Template = enumClass[v];\n        if (!c) {\n          const n = combination.map(({ name }) => name).join('|');\n          c = add.call(this, new this(v), n);\n        } else {\n          // Predefined combination case, do nothing\n        }\n\n        combinations[c.name] = c;\n      }\n      /* eslint-enable no-bitwise */\n\n      Object.freeze(combinations);\n\n      for (const n of Object.keys(combinations)) delete Items[n]; // 👈 Transfer predefined combinations from Items\n    }\n\n    // After transfer predefined combinations\n    {\n      const values = Object.freeze(\n        Object.values(Items)\n          .map(({ value }) => value)\n          .sort((a, b) => a - b)\n      );\n\n      // Sorted by `this.values` order!\n      const names = Object.freeze(values.map((v) => from(v).name));\n\n      Object.defineProperties(this, {\n        keys: { value: names, writable: false },\n        names: { value: names, writable: false },\n        values: { value: values, writable: false }\n      });\n    }\n\n    Object.freeze(Items);\n\n    return Object.assign(\n      enumClass,\n      initExt && initExt(enumClass)\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    ) as any;\n  }\n\n  /**\n   * @summary Access to `class`. ⚠ Use with caution when there is a complex hierarchy\n   */\n  protected get meta() {\n    return Object.getPrototypeOf(this).constructor;\n  }\n\n  private _name: string;\n\n  constructor(value: TValue) {\n    super(value);\n  }\n\n  public get name(): string {\n    return this._name;\n  }\n\n  protected toString() {\n    return this.name;\n  }\n\n  protected toJSON() {\n    const { ToJSONField } = this.meta;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return (this as any)[ToJSONField];\n  }\n}\n\nif (!('AVStantso_EnumClass' in globalThis))\n  Object.defineProperties(globalThis, {\n    AVStantso_EnumClass: {\n      value: AVStantso_EnumClass,\n      writable: false,\n      configurable: false\n    }\n  });\n","import EnumClass = AVStantso_EnumClass;\n\nexport {\n  EnumClass\n};\n"],"names":["AVStantso_EnumClass"],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@avstantso/utils-enum-class",
   "license": "MIT",
   "author": "avstantso",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "AVStantso framework utils: EnumClass",
   "keywords": [
     "EnumClass"
@@ -23,12 +23,12 @@
     "test": "NODE_ENV=test jest --coverage"
   },
   "dependencies": {
-    "@avstantso/concepts": "1.1.0",
-    "@avstantso/core": "1.1.0",
-    "@avstantso/errors": "1.1.0",
-    "@avstantso/js": "1.1.0",
-    "@avstantso/std-ext": "1.1.0",
-    "@avstantso/ts": "1.1.0"
+    "@avstantso/concepts": "1.2.1",
+    "@avstantso/core": "1.2.1",
+    "@avstantso/errors": "1.2.1",
+    "@avstantso/js": "1.2.1",
+    "@avstantso/std-ext": "1.2.1",
+    "@avstantso/ts": "1.2.1"
   },
   "devDependencies": {
     "@avstantso/dev-basic": "1.0.0"