@avstantso/js 1.1.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.
 
 ## [1.1.0] - 2026-01-18

package/dist/_global/_register.d.ts

@@ -0,0 +1,35 @@
+declare namespace AVStantso {
+    /**
+     * @summary JavaScript helpers
+     */
+    namespace JS {
+        /**
+         * @summary JS types (available resault of `typeof`)
+         */
+        type Type = keyof AVStantso.TS.Literal.Builtins;
+    }
+    namespace Code {
+        namespace JS {
+            /**
+             * @summary Map of JS types (available resault of `typeof`).
+             */
+            type Types = Readonly<AVStantso.TS.Key2Key<AVStantso.JS.Type>>;
+        }
+        /**
+         * @summary JavaScript helpers utility
+         */
+        interface JS extends JS.Types {
+            /**
+             * @summary Map of JS types (available resault of `typeof`).
+             */
+            Types: JS.Types;
+        }
+    }
+    interface Code {
+        /**
+         * @summary JavaScript helpers utility
+         */
+        JS: Code.JS;
+    }
+    const JS: Code.JS;
+}

package/dist/_global/index.d.ts

@@ -0,0 +1,4 @@
+import './_register';
+import './is';
+import './type-info';
+import './switch';

package/dist/_global/is.d.ts

@@ -0,0 +1,60 @@
+declare namespace AVStantso {
+    namespace Code {
+        namespace JS {
+            namespace Is {
+                export type Func<B> = <T extends B = B>(candidate: unknown) => candidate is T;
+                export type TypeFunc = <T>(type: AVStantso.JS.Type, candidate: unknown) => candidate is T;
+                export type ClassFunc<B extends object = object> = <T extends B = B>(objClass: AVStantso.TS.Class<T>, candidate: unknown) => candidate is T;
+                export type ByTypes = {
+                    [K in AVStantso.JS.Type]: Func<AVStantso.TS.Literal.Builtins[K]>;
+                };
+                export type ByClasses = {
+                    class: ClassFunc;
+                    error: ClassFunc<Error>;
+                };
+                export type ByCombination = {
+                    /**
+                     * @summary Wrapper on `typeof XXX === 'object' || typeof XXX === 'function'`\
+                     * — type that posible use with `Object.defineProperty`.
+                     */
+                    structure: Func<object | Function>;
+                };
+                namespace OneOf {
+                    type Set<T> = [set?: ReadonlyArray<T> | ReadonlySet<T>] | [...set: T[]];
+                    export type Func<B> = <T extends B = B>(candidate: unknown, ...set: Set<T>) => candidate is T;
+                    export type TypeFunc = <T>(type: AVStantso.JS.Type, candidate: unknown, ...set: Set<T>) => candidate is T;
+                    export type ClassFunc<B extends object = object> = <T extends B = B>(objClass: AVStantso.TS.Class<T>, candidate: unknown, ...set: Set<AVStantso.TS.Class<T>>) => candidate is T;
+                    export type ByTypes = {
+                        [K in AVStantso.JS.Type]: Func<AVStantso.TS.Literal.Builtins[K]>;
+                    };
+                    export type ByClasses = {
+                        class: ClassFunc;
+                        error: ClassFunc<Error>;
+                    };
+                    export type ByCombination = {
+                        /**
+                         * @summary Wrapper on `typeof XXX === 'object' || typeof XXX === 'function'`\
+                         * — type that posible use with `Object.defineProperty`.\
+                         * _Short ~synonym of `TS.Structure.is`_
+                         * @see TS.Structure.is
+                         */
+                        structure: Func<'object' | 'function'>;
+                    };
+                    export {};
+                }
+                export type OneOf = OneOf.TypeFunc & OneOf.ByTypes & OneOf.ByClasses & OneOf.ByCombination;
+                export {};
+            }
+            export type Is = Is.TypeFunc & Is.ByTypes & Is.ByClasses & Is.ByCombination & {
+                oneOf: Is.OneOf;
+            };
+            export {};
+        }
+        interface JS {
+            /**
+             * @summary Wrapper on `typeof XXX === YYY` and `instanceof`
+             */
+            is: JS.Is;
+        }
+    }
+}

package/dist/_global/switch.d.ts

@@ -0,0 +1,50 @@
+declare namespace AVStantso {
+    namespace JS.Switch {
+        /**
+         * @summary Cases key for switch value by `typeof`
+         */
+        type Key = Type | 'null' | 'default';
+        /**
+         * @summary Case for switch value by `typeof`
+         */
+        type Case<R, K extends Key> = TS.Func.Is<R, never, R> | (K extends 'default' ? (<P>(arg: P, ...params: TS.Arr) => R) : K extends 'undefined' | 'null' ? (...params: TS.Arr) => R : <P extends TS.Literal.Builtins[Extract<K, Type>]>(arg: P, ...params: TS.Arr) => R);
+        /**
+         * @summary Cases for switch value by `typeof` key + `null` + `default` case
+         */
+        type Cases<R> = {
+            [K in Key]?: Case<R, K>;
+        };
+    }
+    namespace Code {
+        interface JS {
+            /**
+             * @summary Switch value by `typeof` key function or default key
+             * @template R Case result type
+             * @template T Argument data type
+             * @template Cases Infer type of cases
+             * @param data Data for get `typeof` and switch
+             * @param cases Cases of switch
+             * @example
+             * const uk = JS.switch(15, { string: 46, number: 98 });
+             * expect(uk).toBe(98);
+             * 
+             * const s: string = JS.switch(uk, { default: 'xyz' });
+             * expect(s).toBe('xyz');
+             * 
+             * const o = JS.switch<number>({}, { object: 14, default: 86, string: 42 });
+             * expect(o).toBe(14);
+             * 
+             * const nl = JS.switch(null, { default: 1, object: 2, null: 3, undefined: 4, string: 5 });
+             * expect(nl).toBe(3);
+             * 
+             * const calc: string = JS.switch({ name: 'Jon' } as unknown, {
+             *   string: (v) => v.repeat(2),
+             *   object: (v: { name?: string }) => v.name,
+             *   number: '!!!'
+             * });
+             * expect(calc).toBe('Jon');
+             */
+            switch<R, T = unknown, Cases extends AVStantso.JS.Switch.Cases<R> = AVStantso.JS.Switch.Cases<R>>(data: T, cases: Cases): R;
+        }
+    }
+}

package/dist/_global/type-info.d.ts

@@ -0,0 +1,33 @@
+declare namespace AVStantso {
+    namespace JS {
+        namespace TypeInfo {
+            /**
+             * @summary Runtime type information provider for objects
+             */
+            type Provider = {
+                /**
+                 * @summary Runtime type information for objects
+                 */
+                typeInfo: TypeInfo;
+            };
+        }
+        /**
+         * @summary Runtime type information for objects
+         * @description For example, I use this mechanism when dynamically rendering React components.\
+         * If an attribute has no value, but is declared as `boolean` in `typeInfo`, the value is interpreted as `true`.
+         */
+        type TypeInfo = NodeJS.ReadOnlyDict<TS.Literal>;
+    }
+    namespace Code {
+        interface JS {
+            /**
+             * @summary Check exists `typeInfo` in `object` or `Function`
+             */
+            hasTypeInfo(candidate: unknown): candidate is AVStantso.JS.TypeInfo.Provider;
+            /**
+             * @summary Try get `typeInfo` from `object` or `Function` if it exists
+             */
+            tryTypeInfo(candidate: unknown): AVStantso.JS.TypeInfo;
+        }
+    }
+}

package/dist/export.d.ts

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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import '@avstantso/ts';
+import './_global';
+export * from './export';

package/dist/index.js

@@ -0,0 +1,94 @@
+'use strict';
+
+require('@avstantso/ts');
+
+var AVStantso$2;
+(function (AVStantso) {
+    AVStantso.JS = avstantso._reg.JS(({ TS }) => {
+        const Types = Object.freeze(Object.fromEntries(TS.Literal.Builtins.map((t) => [t, t])));
+        return { ...Types, Types };
+    });
+})(AVStantso$2 || (AVStantso$2 = {}));
+
+(function (AVStantso) {
+    avstantso._reg.JS.is(({ TS }) => {
+        function checkInSet(candidate, params) {
+            if (params.length) {
+                if ('object' === typeof params[0]) {
+                    if (params[0] instanceof Set)
+                        return params[0].has(candidate);
+                    if (Array.isArray(params[0]))
+                        return params[0].includes(candidate);
+                }
+                return params.includes(candidate);
+            }
+            return true;
+        }
+        function is(type, candidate, ...params) {
+            return (type === typeof candidate) && (!params.length || checkInSet(candidate, params));
+        }
+        function isClass(objClass, candidate, ...params) {
+            try {
+                return (candidate
+                    && 'object' === typeof candidate
+                    && candidate instanceof objClass
+                    && (!params.length || checkInSet(candidate, params)));
+            }
+            catch (e) {
+                e.candidate = candidate;
+                throw e;
+            }
+        }
+        function isStructure(candidate, ...params) {
+            return TS.Structure.is(candidate)
+                && (!params.length || checkInSet(candidate, params));
+        }
+        is.class = isClass;
+        is.error = isClass;
+        is.structure = isStructure;
+        for (const type of TS.Literal.Builtins)
+            Object.defineProperty(is, type, {
+                value: is.bind(null, type),
+                writable: false
+            });
+        Object.defineProperties(is, { oneOf: { get: () => is } });
+        return is;
+    });
+})();
+
+(function (AVStantso) {
+    avstantso._reg.JS.hasTypeInfo(() => function hasTypeInfo(candidate) {
+        const { typeInfo } = (candidate || {});
+        return !!typeInfo && 'object' === typeof typeInfo;
+    });
+    avstantso._reg.JS.tryTypeInfo(() => function tryTypeInfo(candidate) {
+        const { typeInfo } = (candidate || {});
+        return 'object' === typeof typeInfo && typeInfo;
+    });
+})();
+
+var AVStantso$1;
+(function (AVStantso) {
+    (function (Code) {
+        avstantso._reg.JS.switch(() => {
+            function _switch(data, cases) {
+                function resolve(value) {
+                    return 'function' === typeof value ? value(data) : value;
+                }
+                if (null === data && 'null' in cases)
+                    return resolve(cases.null);
+                const t = typeof data;
+                if (t in cases)
+                    return resolve(cases[t]);
+                if ('default' in cases)
+                    return resolve(cases.default);
+            }
+            return _switch;
+        });
+    })(AVStantso.Code || (AVStantso.Code = {}));
+})(AVStantso$1 || (AVStantso$1 = {}));
+
+var JS = AVStantso.JS;
+
+exports.JS = JS;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/_global/_register.ts","../src/_global/is.ts","../src/_global/type-info.ts","../src/_global/switch.ts","../src/export.ts"],"sourcesContent":["namespace AVStantso {\n  /**\n   * @summary JavaScript helpers\n   */\n  export namespace JS {\n    /**\n     * @summary JS types (available resault of `typeof`)\n     */\n    export type Type = keyof AVStantso.TS.Literal.Builtins;\n  }\n\n  export namespace Code {\n    export namespace JS {\n      /**\n       * @summary Map of JS types (available resault of `typeof`).\n       */\n      export type Types = Readonly<AVStantso.TS.Key2Key<AVStantso.JS.Type>>;\n    }\n\n    /**\n     * @summary JavaScript helpers utility\n     */\n    export interface JS extends JS.Types {\n      /**\n       * @summary Map of JS types (available resault of `typeof`).\n       */\n      Types: JS.Types;\n    }\n  }\n\n  export interface Code {\n    /**\n     * @summary JavaScript helpers utility\n     */\n    JS: Code.JS;\n  }\n\n  export const JS: Code.JS = avstantso._reg.JS(({ TS }) => {\n    const Types = Object.freeze(\n      Object.fromEntries(\n        TS.Literal.Builtins.map((t) => [t, t])\n      ) as Code.JS.Types\n    );\n\n    return { ...Types, Types };\n  });\n}\n","namespace AVStantso {\n  export namespace Code {\n    export namespace JS {\n      namespace Is {\n        export type Func<B> = <T extends B = B>(\n          candidate: unknown\n        ) => candidate is T;\n\n        export type TypeFunc = <T>(\n          type: AVStantso.JS.Type,\n          candidate: unknown\n        ) => candidate is T;\n\n        export type ClassFunc<B extends object = object> = <T extends B = B>(\n          objClass: AVStantso.TS.Class<T>,\n          candidate: unknown\n        ) => candidate is T;\n\n        export type ByTypes = {\n          [K in AVStantso.JS.Type]: Func<AVStantso.TS.Literal.Builtins[K]>;\n        };\n\n        export type ByClasses = {\n          class: ClassFunc;\n          error: ClassFunc<Error>;\n        };\n\n        export type ByCombination = {\n          /**\n           * @summary Wrapper on `typeof XXX === 'object' || typeof XXX === 'function'`\\\n           * — type that posible use with `Object.defineProperty`.\n           */\n          // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type\n          structure: Func<object | Function>;\n        };\n\n        namespace OneOf {\n          type Set<T> = [set?: ReadonlyArray<T> | ReadonlySet<T>] | [...set: T[]];\n\n          export type Func<B> = <T extends B = B>(\n            candidate: unknown,\n            ...set: Set<T>\n          ) => candidate is T;\n\n          export type TypeFunc = <T>(\n            type: AVStantso.JS.Type,\n            candidate: unknown,\n            ...set: Set<T>\n          ) => candidate is T;\n\n          export type ClassFunc<B extends object = object> = <T extends B = B>(\n            objClass: AVStantso.TS.Class<T>,\n            candidate: unknown,\n            ...set: Set<AVStantso.TS.Class<T>>\n          ) => candidate is T;\n\n          export type ByTypes = {\n            [K in AVStantso.JS.Type]: Func<AVStantso.TS.Literal.Builtins[K]>;\n          };\n\n          export type ByClasses = {\n            class: ClassFunc;\n            error: ClassFunc<Error>;\n          };\n\n          export type ByCombination = {\n            /**\n             * @summary Wrapper on `typeof XXX === 'object' || typeof XXX === 'function'`\\\n             * — type that posible use with `Object.defineProperty`.\\\n             * _Short ~synonym of `TS.Structure.is`_\n             * @see TS.Structure.is\n             */\n            structure: Func<'object' | 'function'>;\n          };\n        }\n\n        export type OneOf = OneOf.TypeFunc & OneOf.ByTypes & OneOf.ByClasses & OneOf.ByCombination;\n      }\n\n      export type Is = Is.TypeFunc & Is.ByTypes & Is.ByClasses & Is.ByCombination & {\n        oneOf: Is.OneOf;\n      };\n    }\n\n    export interface JS {\n      /**\n       * @summary Wrapper on `typeof XXX === YYY` and `instanceof`\n       */\n      is: JS.Is;\n    }\n  }\n\n  avstantso._reg.JS.is(({ TS }) => {\n    function checkInSet(candidate: unknown, params: TS.Arr) {\n      if (params.length) {\n        if ('object' === typeof params[0]) {\n          if (params[0] instanceof Set)\n            return params[0].has(candidate);\n\n          if (Array.isArray(params[0]))\n            return params[0].includes(candidate);\n        }\n\n        return params.includes(candidate);\n      }\n\n      return true;\n    }\n\n\n    function is(type: string, candidate: unknown, ...params: TS.Arr) {\n      return (type === typeof candidate) && (!params.length || checkInSet(candidate, params));\n    }\n\n    function isClass(objClass: TS.Class, candidate: unknown, ...params: TS.Arr) {\n      try {\n        return (\n          candidate\n          && 'object' === typeof candidate\n          && candidate instanceof objClass\n          && (!params.length || checkInSet(candidate, params))\n        );\n      } catch (e) {\n        e.candidate = candidate;\n        throw e;\n      }\n    }\n\n    function isStructure(candidate: unknown, ...params: TS.Arr) {\n      return TS.Structure.is(candidate)\n        && (!params.length || checkInSet(candidate, params));\n    }\n\n    is.class = isClass;\n    is.error = isClass;\n    is.structure = isStructure;\n\n    for (const type of TS.Literal.Builtins)\n      Object.defineProperty(is, type, {\n        value: is.bind(null, type),\n        writable: false\n      });\n\n    Object.defineProperties(is, { oneOf: { get: () => is } });\n\n    return is as Code.JS.Is;\n  });\n}\n","namespace AVStantso {\n  export namespace JS {\n    export namespace TypeInfo {\n      /**\n       * @summary Runtime type information provider for objects\n       */\n      export type Provider = {\n        /**\n         * @summary Runtime type information for objects\n         */\n        typeInfo: TypeInfo;\n      };\n    }\n\n    /**\n     * @summary Runtime type information for objects\n     * @description For example, I use this mechanism when dynamically rendering React components.\\\n     * If an attribute has no value, but is declared as `boolean` in `typeInfo`, the value is interpreted as `true`.\n     */\n    export type TypeInfo = NodeJS.ReadOnlyDict<TS.Literal>;\n  }\n\n  export namespace Code {\n    export interface JS {\n      /**\n       * @summary Check exists `typeInfo` in `object` or `Function`\n       */\n      hasTypeInfo(\n        candidate: unknown\n      ): candidate is AVStantso.JS.TypeInfo.Provider;\n\n      /**\n       * @summary Try get `typeInfo` from `object` or `Function` if it exists\n       */\n      tryTypeInfo(candidate: unknown): AVStantso.JS.TypeInfo;\n    }\n  }\n\n  avstantso._reg.JS.hasTypeInfo(\n    () =>\n      function hasTypeInfo(candidate: unknown): candidate is JS.TypeInfo.Provider {\n        const { typeInfo } = (candidate || {}) as JS.TypeInfo.Provider;\n        return !!typeInfo && 'object' === typeof typeInfo;\n      }\n  );\n\n  avstantso._reg.JS.tryTypeInfo(\n    () =>\n      function tryTypeInfo(candidate: unknown){\n        const { typeInfo } = (candidate || {}) as JS.TypeInfo.Provider;\n        return 'object' === typeof typeInfo && typeInfo;\n      }\n  );\n}\n","namespace AVStantso {\n  export namespace JS.Switch {\n    /**\n     * @summary Cases key for switch value by `typeof`\n     */\n    export type Key = Type | 'null' | 'default';\n\n    /**\n     * @summary Case for switch value by `typeof`\n     */\n    export type Case<R, K extends Key> = TS.Func.Is<R, never, R>\n      | (K extends 'default'\n        ? (<P>(arg: P, ...params: TS.Arr) => R)\n        : K extends 'undefined' | 'null'\n          ? (...params: TS.Arr) => R\n          : <P extends TS.Literal.Builtins[Extract<K, Type>]>(\n            arg: P, ...params: TS.Arr\n          ) => R\n      );\n\n    /**\n     * @summary Cases for switch value by `typeof` key + `null` + `default` case\n     */\n    export type Cases<R> = {\n      [K in Key]?: Case<R, K>;\n    };\n  }\n\n  export namespace Code {\n    export interface JS {\n      /**\n       * @summary Switch value by `typeof` key function or default key\n       * @template R Case result type\n       * @template T Argument data type\n       * @template Cases Infer type of cases\n       * @param data Data for get `typeof` and switch\n       * @param cases Cases of switch\n       * @EXAMPLE(@JS.Switch)\n       */\n      switch<\n        R,\n        T = unknown,\n        Cases extends AVStantso.JS.Switch.Cases<R> = AVStantso.JS.Switch.Cases<R>\n      >(data: T, cases: Cases): R;\n    }\n\n    avstantso._reg.JS.switch(() => {\n      function _switch(data: unknown, cases: NodeJS.Dict<unknown>) {\n        function resolve(value: unknown) {\n          return 'function' === typeof value ? value(data) : value;\n        }\n\n        if (null === data && 'null' in cases)\n          return resolve(cases.null);\n\n        const t = typeof data;\n        if (t in cases)\n          return resolve(cases[t]);\n\n        if ('default' in cases)\n          return resolve(cases.default);\n      }\n\n      return _switch;\n    });\n  }\n}\n","import JS = AVStantso.JS;\nexport { JS };\n"],"names":["AVStantso"],"mappings":"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"}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@avstantso/js",
   "license": "MIT",
   "author": "avstantso",
-  "version": "1.1.0",
+  "version": "1.2.2",
   "description": "JavaScript helpers",
   "keywords": [
     "JavaScript"
@@ -23,9 +23,9 @@
     "test": "NODE_ENV=test jest --coverage"
   },
   "dependencies": {
-    "@avstantso/core": "1.1.0",
-    "@avstantso/std-ext": "1.1.0",
-    "@avstantso/ts": "1.1.0"
+    "@avstantso/core": "1.2.1",
+    "@avstantso/std-ext": "1.2.1",
+    "@avstantso/ts": "1.3.0"
   },
   "devDependencies": {
     "@avstantso/dev-basic": "1.0.0"