@avstantso/utils-enum-simple 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+
+## [1.2.2] - 2026-01-31
+
+### Changed
+
+- Updated `@avstantso/ts` dependency (Updated @avstantso/ts dependency (fix String, Filter))
+
+
+## [1.2.1] - 2026-01-18
+
+### Changed
+
+- Fix publishing
+
 All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),

package/dist/_global/_register.d.ts

@@ -0,0 +1,160 @@
+declare namespace AVStantso {
+    /**
+     * @summary [`E`]num[`K`]ey[`M`]ap
+     */
+    type EKM<Values extends ReadonlyArray<string>, K2K extends TS.Array.ToKey2Key<Values> = TS.Array.ToKey2Key<Values>> = Pick<K2K, TS.Func.Restrict<keyof K2K>>;
+    /**
+     * @summary Array of const wrapper enum
+     * @example
+     * const [Enum, Def] = SimpleEnum.Factory(
+     *   'ProgLang',
+     *   ['JS', 'TS', 'C', 'C++'] as const
+     * );
+     * 
+     * type Def = typeof Def;
+     * 
+     * export const ProgLang = Enum;
+     * export type ProgLang = Def['Key'];
+     * 
+     * export namespace ProgLang {
+     *   export type Values = Def['Values'];
+     *   export type Map = Def['Map'];
+     * 
+     *   export type Record<T> = globalThis.Record<Def['Key'], T>;
+     * }
+     * @example
+     * const [Enum, Def] = SimpleEnum.Factory.Raw(
+     *   'FileFormat',
+     *   ['TXT', 'JSON', 'XLS'] as const
+     * );
+     * 
+     * type Def = typeof Def;
+     * 
+     * function isBinary(ff: FileFormat) {
+     *   return 'XLS' === ff;
+     * }
+     * for (const ff of Enum)
+     *   Object.defineProperty(isBinary, ff, { get: isBinary.bind(null, ff) });
+     * 
+     * const Caption = Enum.RecValid<string>().withFreeze({
+     *   TXT: 'Text file',
+     *   JSON: 'JavaScript Object Notation file',
+     *   XLS: 'Excel < 2007 file'
+     * } as const);
+     * 
+     * export const FileFormat = Object.freeze(
+     *   Object.assign(
+     *     Enum,
+     *     { isBinary, Caption }
+     *   ) as typeof Enum & {
+     *     isBinary: typeof isBinary & {
+     *       [K in Def['Key']]: boolean;
+     *     },
+     *     Caption: typeof Caption
+     *   }
+     * );
+     * export type FileFormat = Def['Key'];
+     * 
+     * export namespace FileFormat {
+     *   export type Values = Def['Values'];
+     *   export type Map = Def['Map'];
+     * 
+     *   export type Record<T> = globalThis.Record<Def['Key'], T>;
+     * }
+     */
+    export namespace SimpleEnum {
+        /**
+         * @summary Object is `SimpleEnum` check
+         */
+        type Is<Values extends ReadonlyArray<string>, EnumKeyMap extends EKM<Values> = EKM<Values>, EnumKey extends keyof EnumKeyMap = keyof EnumKeyMap> = {
+            (candidate: unknown): candidate is EnumKey;
+        } & {
+            [K in EnumKey]: (candidate: unknown) => candidate is K;
+        };
+        /**
+         * @summary Record validator
+         */
+        type RecValid<Values extends ReadonlyArray<string>, EnumKeyMap extends EKM<Values> = EKM<Values>, EnumKey extends keyof EnumKeyMap = keyof EnumKeyMap, T = unknown> = {
+            /**
+             * @summary Record validator
+             */
+            <R extends Record<EnumKey, T>>(rec: R): R;
+            /**
+             * @summary Record validator with `Object.freeze`
+             */
+            withFreeze<R extends Record<EnumKey, T>>(rec: R): Readonly<R>;
+        };
+        /**
+         * @summary `[Enum, Def]`: enum controller & definition for use `typeof Def`
+         */
+        type Definition<TypeName extends string, Values extends ReadonlyArray<string>, EnumKeyMap extends EKM<Values> = EKM<Values>, EnumKey extends keyof EnumKeyMap = keyof EnumKeyMap> = [
+            EnumKeyMap & {
+                (value: string, defaultValue: EnumKey): EnumKey;
+                (value: string): EnumKey;
+                values: Values;
+                Set: new <T extends EnumKey = EnumKey>(values?: readonly T[] | null) => Set<T>;
+                is: Is<Values, EnumKeyMap, EnumKey>;
+                map: Values['map'];
+                indexOf: Values['indexOf'];
+                [Symbol.iterator]: Values[typeof Symbol.iterator];
+                RecValid<T>(): RecValid<Values, EnumKeyMap, EnumKey, T>;
+            },
+            {
+                Name: TypeName;
+                Values: Values;
+                Key: EnumKey;
+                Map: EnumKeyMap;
+                Set: Set<EnumKey>;
+            }?
+        ];
+    }
+    export namespace Code {
+        namespace SimpleEnum {
+            /**
+             * Create simple enum
+             * @param typeName Enum name
+             * @param values Enum values
+             * @param unfreezed D'nt freeze result
+             * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`
+             */
+            type Factory = {
+                /**
+                 * Create simple enum
+                 * @param typeName Enum name
+                 * @param values Enum values
+                 * @param unfreezed D'nt freeze result
+                 * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`
+                 */
+                <TypeName extends string, Values extends ReadonlyArray<string>>(typeName: TypeName, values: Values, unfreezed?: boolean): AVStantso.SimpleEnum.Definition<TypeName, Values>;
+                /**
+                 * @summary Create simple enum. Keep result unfreezed
+                 * @param typeName Enum name
+                 * @param values Enum values
+                 * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`
+                 */
+                Raw<TypeName extends string, Values extends ReadonlyArray<string>>(typeName: TypeName, values: Values): AVStantso.SimpleEnum.Definition<TypeName, Values>;
+            };
+        }
+        /**
+         * @summary SimpleEnum utilities
+         */
+        interface SimpleEnum {
+            /**
+             * Create simple enum
+             * @param typeName Enum name
+             * @param values Enum values
+             * @param unfreezed D'nt freeze result
+             * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`
+             */
+            Factory: SimpleEnum.Factory;
+        }
+    }
+    export interface Code {
+        /**
+         * @summary SimpleEnum utilities
+         */
+        SimpleEnum: Code.SimpleEnum;
+    }
+    export const SimpleEnum: Code.SimpleEnum;
+    export {};
+}

package/dist/_global/index.d.ts

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

package/dist/export.d.ts

@@ -0,0 +1,2 @@
+import SimpleEnum = AVStantso.SimpleEnum;
+export { SimpleEnum };

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,55 @@
+'use strict';
+
+require('@avstantso/errors');
+require('@avstantso/js');
+
+var AVStantso$1;
+(function (AVStantso) {
+    AVStantso.SimpleEnum = avstantso._reg.SimpleEnum(({ Func, Generic, TS }) => {
+        function SimpleEnumFactory(typeName, values, unfreezed) {
+            Object.freeze(values);
+            const map = TS.Array.ToKey2Key(values);
+            function is(canditate) {
+                return values.includes(canditate);
+            }
+            Object.assign(is, Object.fromEntries(values.filter(Func.isPropAllowed).map((k) => [
+                k,
+                (canditate) => canditate === k
+            ])));
+            function validateAndCast(value, ...params) {
+                if (!value && params.length)
+                    return params[0];
+                if (undefined === value || null === value)
+                    return value;
+                if (!is(value)) {
+                    if (params.length)
+                        return params[0];
+                    throw new AVStantso_InvalidArgumentError(typeName, validateAndCast, { value }, `${typeName} must be one of [${values.join(',')}] but it's ${value}`);
+                }
+                return value;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const result = Object.assign(validateAndCast, map, {
+                values,
+                Set,
+                is,
+                map: values.map.bind(values),
+                indexOf: values.indexOf.bind(values),
+                [Symbol.iterator]: values[Symbol.iterator].bind(values),
+                RecValid: Generic.Validator
+            });
+            return [
+                unfreezed ? result : Object.freeze(result)
+            ];
+        }
+        SimpleEnumFactory.Raw = function SimpleEnumFactoryRaw(typeName, values) {
+            return SimpleEnumFactory(typeName, values, true);
+        };
+        return { Factory: SimpleEnumFactory };
+    });
+})(AVStantso$1 || (AVStantso$1 = {}));
+
+var SimpleEnum = AVStantso.SimpleEnum;
+
+exports.SimpleEnum = SimpleEnum;
+//# 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":["namespace AVStantso {\n  /**\n   * @summary [`E`]num[`K`]ey[`M`]ap\n   */\n  type EKM<\n    Values extends ReadonlyArray<string>,\n    K2K extends TS.Array.ToKey2Key<Values> = TS.Array.ToKey2Key<Values>\n  > = Pick<K2K, TS.Func.Restrict<keyof K2K>>;\n\n  /**\n   * @summary Array of const wrapper enum\n   * @EXAMPLE(@SimpleEnum)\n   * @EXAMPLE(@SimpleEnum.Raw)\n   */\n  export namespace SimpleEnum {\n    /**\n     * @summary Object is `SimpleEnum` check\n     */\n    export type Is<\n      Values extends ReadonlyArray<string>,\n      EnumKeyMap extends EKM<Values> = EKM<Values>,\n      EnumKey extends keyof EnumKeyMap = keyof EnumKeyMap\n    > = {\n      (candidate: unknown): candidate is EnumKey;\n    } & {\n      [K in EnumKey]: (candidate: unknown) => candidate is K;\n    };\n\n    /**\n     * @summary Record validator\n     */\n    export type RecValid<\n      Values extends ReadonlyArray<string>,\n      EnumKeyMap extends EKM<Values> = EKM<Values>,\n      EnumKey extends keyof EnumKeyMap = keyof EnumKeyMap,\n      T = unknown\n    > = {\n      /**\n       * @summary Record validator\n       */\n      <R extends Record<EnumKey, T>>(rec: R): R;\n\n      /**\n       * @summary Record validator with `Object.freeze`\n       */\n      withFreeze<R extends Record<EnumKey, T>>(rec: R): Readonly<R>;\n    };\n\n    /**\n     * @summary `[Enum, Def]`: enum controller & definition for use `typeof Def`\n     */\n    export type Definition<\n      TypeName extends string,\n      Values extends ReadonlyArray<string>,\n      EnumKeyMap extends EKM<Values> = EKM<Values>,\n      EnumKey extends keyof EnumKeyMap = keyof EnumKeyMap\n    > = [\n      EnumKeyMap & {\n        (value: string, defaultValue: EnumKey): EnumKey;\n        (value: string): EnumKey;\n        values: Values;\n        Set: new <T extends EnumKey = EnumKey>(values?: readonly T[] | null) => Set<T>;\n        is: Is<Values, EnumKeyMap, EnumKey>,\n        map: Values['map'];\n        indexOf: Values['indexOf'];\n        [Symbol.iterator]: Values[typeof Symbol.iterator];\n        RecValid<T>(): RecValid<Values, EnumKeyMap, EnumKey, T>;\n      },\n      {\n        Name: TypeName;\n        Values: Values;\n        Key: EnumKey;\n        Map: EnumKeyMap;\n        Set: Set<EnumKey>;\n      }? // 👈used for typeof only\n    ];\n  }\n\n  export namespace Code {\n    export namespace SimpleEnum {\n      /**\n       * Create simple enum\n       * @param typeName Enum name\n       * @param values Enum values\n       * @param unfreezed D'nt freeze result\n       * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`\n       */\n      export type Factory = {\n        /**\n         * Create simple enum\n         * @param typeName Enum name\n         * @param values Enum values\n         * @param unfreezed D'nt freeze result\n         * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`\n         */\n        <\n          TypeName extends string,\n          Values extends ReadonlyArray<string>\n        >(typeName: TypeName, values: Values, unfreezed?: boolean): AVStantso.SimpleEnum.Definition<\n          TypeName,\n          Values\n        >;\n\n        /**\n         * @summary Create simple enum. Keep result unfreezed\n         * @param typeName Enum name\n         * @param values Enum values\n         * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`\n         */\n        Raw<\n          TypeName extends string,\n          Values extends ReadonlyArray<string>\n        >(typeName: TypeName, values: Values): AVStantso.SimpleEnum.Definition<\n          TypeName,\n          Values\n        >;\n      };\n    }\n\n    /**\n     * @summary SimpleEnum utilities\n     */\n    export interface SimpleEnum {\n      /**\n       * Create simple enum\n       * @param typeName Enum name\n       * @param values Enum values\n       * @param unfreezed D'nt freeze result\n       * @returns `[Enum, Def]`: enum controller & definition for use `typeof Def`\n       */\n      Factory: SimpleEnum.Factory;\n    }\n  }\n\n  export interface Code {\n    /**\n     * @summary SimpleEnum utilities\n     */\n    SimpleEnum: Code.SimpleEnum;\n  }\n\n  export const SimpleEnum: Code.SimpleEnum = avstantso._reg.SimpleEnum(({ Func, Generic, TS }) => {\n    function SimpleEnumFactory<\n      TypeName extends string,\n      Values extends ReadonlyArray<string>,\n      EnumKeyMap extends EKM<Values> = EKM<Values>,\n      EnumKey extends keyof EnumKeyMap = keyof EnumKeyMap\n    >(typeName: TypeName, values: Values, unfreezed?: boolean): AVStantso.SimpleEnum.Definition<\n      TypeName, Values, EnumKeyMap, EnumKey\n    > {\n      Object.freeze(values);\n\n      const map = TS.Array.ToKey2Key(values);\n\n      function is(canditate: unknown) {\n        return values.includes(canditate as string);\n      }\n\n      Object.assign(\n        is,\n        Object.fromEntries(\n          values.filter(Func.isPropAllowed).map((k) => [\n            k,\n            (canditate: unknown) => canditate === k\n          ])\n        )\n      );\n\n      function validateAndCast(value: string, ...params: [EnumKey?]) {\n        if (!value && params.length) return params[0];\n\n        if (undefined === value || null === value) return value as EnumKey;\n\n        if (!is(value)) {\n          if (params.length) return params[0];\n\n          throw new AVStantso_InvalidArgumentError(\n            typeName,\n            validateAndCast,\n            { value },\n            `${typeName} must be one of [${values.join(',')}] but it's ${value}`\n          );\n        }\n\n        return value as EnumKey;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const result: any = Object.assign(\n        validateAndCast,\n        map,\n        {\n          values,\n          Set,\n          is,\n          map: values.map.bind(values),\n          indexOf: values.indexOf.bind(values),\n          [Symbol.iterator]: values[Symbol.iterator].bind(values),\n          RecValid: Generic.Validator\n        }\n      );\n\n      return [\n        unfreezed ? result : Object.freeze(result)\n      ];\n    }\n\n    SimpleEnumFactory.Raw = function SimpleEnumFactoryRaw<\n      TypeName extends string,\n      Values extends ReadonlyArray<string>\n    >(typeName: TypeName, values: Values) {\n      return SimpleEnumFactory(typeName, values, true);\n    };\n\n    return { Factory: SimpleEnumFactory };\n  });\n}\n","import SimpleEnum = AVStantso.SimpleEnum;\n\nexport {\n  SimpleEnum\n};\n"],"names":["AVStantso"],"mappings":";;;;;AAAA,IAAUA,WAAS;AAAnB,CAAA,UAAU,SAAS,EAAA;AA6IJ,IAAA,SAAA,CAAA,UAAU,GAAoB,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,KAAI;AAC7F,QAAA,SAAS,iBAAiB,CAKxB,QAAkB,EAAE,MAAc,EAAE,SAAmB,EAAA;AAGvD,YAAA,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;YAErB,MAAM,GAAG,GAAG,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC;YAEtC,SAAS,EAAE,CAAC,SAAkB,EAAA;AAC5B,gBAAA,OAAO,MAAM,CAAC,QAAQ,CAAC,SAAmB,CAAC;YAC7C;YAEA,MAAM,CAAC,MAAM,CACX,EAAE,EACF,MAAM,CAAC,WAAW,CAChB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK;gBAC3C,CAAC;AACD,gBAAA,CAAC,SAAkB,KAAK,SAAS,KAAK;aACvC,CAAC,CACH,CACF;AAED,YAAA,SAAS,eAAe,CAAC,KAAa,EAAE,GAAG,MAAkB,EAAA;AAC3D,gBAAA,IAAI,CAAC,KAAK,IAAI,MAAM,CAAC,MAAM;AAAE,oBAAA,OAAO,MAAM,CAAC,CAAC,CAAC;AAE7C,gBAAA,IAAI,SAAS,KAAK,KAAK,IAAI,IAAI,KAAK,KAAK;AAAE,oBAAA,OAAO,KAAgB;AAElE,gBAAA,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE;oBACd,IAAI,MAAM,CAAC,MAAM;AAAE,wBAAA,OAAO,MAAM,CAAC,CAAC,CAAC;oBAEnC,MAAM,IAAI,8BAA8B,CACtC,QAAQ,EACR,eAAe,EACf,EAAE,KAAK,EAAE,EACT,CAAA,EAAG,QAAQ,CAAA,iBAAA,EAAoB,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA,WAAA,EAAc,KAAK,CAAA,CAAE,CACrE;gBACH;AAEA,gBAAA,OAAO,KAAgB;YACzB;;YAGA,MAAM,MAAM,GAAQ,MAAM,CAAC,MAAM,CAC/B,eAAe,EACf,GAAG,EACH;gBACE,MAAM;gBACN,GAAG;gBACH,EAAE;gBACF,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC;gBAC5B,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC;AACpC,gBAAA,CAAC,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC;gBACvD,QAAQ,EAAE,OAAO,CAAC;AACnB,aAAA,CACF;YAED,OAAO;AACL,gBAAA,SAAS,GAAG,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM;aAC1C;QACH;QAEA,iBAAiB,CAAC,GAAG,GAAG,SAAS,oBAAoB,CAGnD,QAAkB,EAAE,MAAc,EAAA;YAClC,OAAO,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC;AAClD,QAAA,CAAC;AAED,QAAA,OAAO,EAAE,OAAO,EAAE,iBAAiB,EAAE;AACvC,IAAA,CAAC,CAAC;AACJ,CAAC,EAxNSA,WAAS,KAATA,WAAS,GAAA,EAAA,CAAA,CAAA;;ACAnB,IAAO,UAAU,GAAG,SAAS,CAAC;;;;"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@avstantso/utils-enum-simple",
   "license": "MIT",
   "author": "avstantso",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "AVStantso framework utils: EnumSimple",
   "keywords": [
     "EnumSimple"
@@ -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.2",
+    "@avstantso/core": "1.2.1",
+    "@avstantso/errors": "1.2.1",
+    "@avstantso/js": "1.2.2",
+    "@avstantso/std-ext": "1.2.1",
+    "@avstantso/ts": "1.3.0"
   },
   "devDependencies": {
     "@avstantso/dev-basic": "1.0.0"