@duplojs/utils 1.3.27 → 1.3.29

package/dist/array/concat.d.ts

@@ -1,2 +1,2 @@
-export declare function concat<GenericElement extends unknown>(elements: readonly GenericElement[]): (array: readonly GenericElement[]) => GenericElement[];
-export declare function concat<GenericElement extends unknown>(array: readonly GenericElement[], elements: readonly GenericElement[], ...elementsRest: readonly GenericElement[][]): GenericElement[];
+export declare function concat<GenericFirstArray extends readonly unknown[], GenericSecondArray extends readonly unknown[]>(elements: GenericSecondArray): (array: GenericFirstArray) => (GenericFirstArray[number] | GenericSecondArray[number])[];
+export declare function concat<GenericFirstArray extends readonly unknown[], GenericSecondArray extends readonly unknown[], GenericRest extends readonly unknown[][]>(array: GenericFirstArray, elements: GenericSecondArray, ...elementsRest: GenericRest): (GenericFirstArray[number] | GenericSecondArray[number] | GenericRest[number][number])[];

package/dist/common/falsy.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function falsy(input) {
+    return !input;
+}
+
+exports.falsy = falsy;

package/dist/common/falsy.d.ts

@@ -0,0 +1,2 @@
+import { type FalsyValue, type UnionContain } from "./types";
+export declare function falsy<GenericInput extends unknown>(input: GenericInput): input is (Extract<GenericInput, FalsyValue> | (UnionContain<GenericInput, string> extends true ? "" : never) | (UnionContain<GenericInput, number> extends true ? 0 : never) | (UnionContain<GenericInput, bigint> extends true ? 0n : never));

package/dist/common/falsy.mjs

@@ -0,0 +1,5 @@
+function falsy(input) {
+    return !input;
+}
+
+export { falsy };

package/dist/common/hasKinds.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function hasKinds(...args) {
+    if (args.length === 1) {
+        const [kinds] = args;
+        return (input) => hasKinds(input, kinds);
+    }
+    const [input, kinds] = args;
+    for (const kind of kinds) {
+        if (!kind.has(input)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.hasKinds = hasKinds;

package/dist/common/hasKinds.d.ts

@@ -0,0 +1,4 @@
+import { type Kind, type KindHandler } from "./kind";
+import { type AnyTuple, type UnionToIntersection } from "./types";
+export declare function hasKinds<GenericInput extends unknown, const GenericKindHandlers extends AnyTuple<KindHandler>, GenericKindHandler extends GenericKindHandlers[number]>(kinds: GenericKindHandlers): (input: GenericInput) => input is Extract<GenericInput, UnionToIntersection<GenericKindHandler extends any ? Kind<GenericKindHandler["definition"]> : never>>;
+export declare function hasKinds<GenericInput extends unknown, const GenericKindHandlers extends AnyTuple<KindHandler>, GenericKindHandler extends GenericKindHandlers[number]>(input: GenericInput, kinds: GenericKindHandlers): input is Extract<GenericInput, UnionToIntersection<GenericKindHandler extends any ? Kind<GenericKindHandler["definition"]> : never>>;

package/dist/common/hasKinds.mjs

@@ -0,0 +1,15 @@
+function hasKinds(...args) {
+    if (args.length === 1) {
+        const [kinds] = args;
+        return (input) => hasKinds(input, kinds);
+    }
+    const [input, kinds] = args;
+    for (const kind of kinds) {
+        if (!kind.has(input)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export { hasKinds };

package/dist/common/hasSomeKinds.cjs

@@ -0,0 +1,17 @@
+'use strict';
+
+function hasSomeKinds(...args) {
+    if (args.length === 1) {
+        const [kinds] = args;
+        return (input) => hasSomeKinds(input, kinds);
+    }
+    const [input, kinds] = args;
+    for (const kind of kinds) {
+        if (kind.has(input)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+exports.hasSomeKinds = hasSomeKinds;

package/dist/common/hasSomeKinds.d.ts

@@ -0,0 +1,4 @@
+import { type Kind, type KindHandler } from "./kind";
+import { type AnyTuple } from "./types";
+export declare function hasSomeKinds<GenericInput extends unknown, const GenericKindHandlers extends AnyTuple<KindHandler>, GenericKindHandler extends GenericKindHandlers[number]>(kinds: GenericKindHandlers): (input: GenericInput) => input is Extract<GenericInput, GenericKindHandler extends any ? Kind<GenericKindHandler["definition"]> : never>;
+export declare function hasSomeKinds<GenericInput extends unknown, const GenericKindHandlers extends AnyTuple<KindHandler>, GenericKindHandler extends GenericKindHandlers[number]>(input: GenericInput, kinds: GenericKindHandlers): input is Extract<GenericInput, GenericKindHandler extends any ? Kind<GenericKindHandler["definition"]> : never>;

package/dist/common/hasSomeKinds.mjs

@@ -0,0 +1,15 @@
+function hasSomeKinds(...args) {
+    if (args.length === 1) {
+        const [kinds] = args;
+        return (input) => hasSomeKinds(input, kinds);
+    }
+    const [input, kinds] = args;
+    for (const kind of kinds) {
+        if (kind.has(input)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { hasSomeKinds };

package/dist/common/index.d.ts

@@ -41,3 +41,7 @@ export * from "./createKindIdentifier";
 export * from "./forwardLog";
 export * from "./override";
 export * from "./errorKindNamespace";
+export * from "./truthy";
+export * from "./falsy";
+export * from "./hasSomeKinds";
+export * from "./hasKinds";

package/dist/common/truthy.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function truthy(input) {
+    return !!input;
+}
+
+exports.truthy = truthy;

package/dist/common/truthy.d.ts

@@ -0,0 +1,3 @@
+import { type FalsyValue } from "./types";
+export type TruthyValue<GenericInput extends unknown> = Exclude<GenericInput, FalsyValue>;
+export declare function truthy<GenericInput extends unknown>(input: GenericInput): input is TruthyValue<GenericInput>;

package/dist/common/truthy.mjs

@@ -0,0 +1,5 @@
+function truthy(input) {
+    return !!input;
+}
+
+export { truthy };

package/dist/common/types/falsyValue.d.ts

@@ -0,0 +1 @@
+export type FalsyValue = false | 0 | 0n | "" | null | undefined;

package/dist/common/types/index.d.ts

@@ -42,3 +42,4 @@ export * from "./unwrapArray";
 export * from "./onlyLiteral";
 export * from "./sortType";
 export * from "./maybeGetter";
+export * from "./falsyValue";

package/dist/common/types/predicate.d.ts

@@ -1 +1 @@
-export type Predicate<GenericFunction extends (input: any, ...args: any[]) => input is any> = GenericFunction extends (input: any, ...args: any[]) => input is infer InferredPredicate ? InferredPredicate : never;
+export type Predicate<GenericFunction extends (input: any, ...args: any[]) => boolean> = GenericFunction extends (input: any, ...args: any[]) => input is infer InferredPredicate ? InferredPredicate : Parameters<GenericFunction>[0];

package/dist/either/bool/create.cjs

@@ -7,6 +7,7 @@ function bool(value) {
     return value === undefined
         || value === null
         || value === 0
+        || value === 0n
         || value === ""
         || value === false
         ? falsy.boolFalsy(value)

package/dist/either/bool/create.d.ts

@@ -1,5 +1,5 @@
-import { type IsEqual } from "../../common";
-import { type BoolFalsyValue, type EitherBoolFalsy } from "./falsy";
+import { type FalsyValue, type IsEqual } from "../../common";
+import { type EitherBoolFalsy } from "./falsy";
 import { type EitherBoolTruthy } from "./truthy";
-export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends BoolFalsyValue ? EitherBoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0> : IsEqual<GenericValue, string> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<""> : EitherBoolTruthy<GenericValue>;
+export declare function bool<const GenericValue extends unknown = undefined>(value: GenericValue): GenericValue extends FalsyValue ? EitherBoolFalsy<GenericValue> : IsEqual<GenericValue, number> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0> : IsEqual<GenericValue, bigint> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<0n> : IsEqual<GenericValue, string> extends true ? EitherBoolTruthy<GenericValue> | EitherBoolFalsy<""> : EitherBoolTruthy<GenericValue>;
 export type Bool<GenericValue extends unknown> = EitherBoolTruthy<GenericValue> | EitherBoolFalsy;

package/dist/either/bool/create.mjs

@@ -5,6 +5,7 @@ function bool(value) {
     return value === undefined
         || value === null
         || value === 0
+        || value === 0n
         || value === ""
         || value === false
         ? boolFalsy(value)

package/dist/either/bool/falsy.d.ts

@@ -1,15 +1,14 @@
-import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink } from "../../common";
+import { type EscapeVoid, type AnyValue, type Unwrap, type BreakGenericLink, type FalsyValue } from "../../common";
 import { type Kind } from "../../common/kind";
 import { eitherBoolKind } from "./base";
 import { bool } from "./create";
 import { type EitherLeft } from "../left";
 import { type EitherRight } from "../right";
-export type BoolFalsyValue = 0 | "" | undefined | null | false;
 export declare const eitherBoolFalsyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsEither/bool-falsy", unknown>>;
-type _EitherBoolFalsy<GenericValue extends BoolFalsyValue = BoolFalsyValue> = (EitherLeft<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolFalsyKind.definition>);
-export interface EitherBoolFalsy<GenericValue extends BoolFalsyValue = BoolFalsyValue> extends _EitherBoolFalsy<GenericValue> {
+type _EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> = (EitherLeft<"bool", GenericValue> & Kind<typeof eitherBoolKind.definition> & Kind<typeof eitherBoolFalsyKind.definition>);
+export interface EitherBoolFalsy<GenericValue extends FalsyValue = FalsyValue> extends _EitherBoolFalsy<GenericValue> {
 }
-export declare function boolFalsy<const GenericValue extends BoolFalsyValue = undefined>(value?: GenericValue): EitherBoolFalsy<GenericValue>;
+export declare function boolFalsy<const GenericValue extends FalsyValue = undefined>(value?: GenericValue): EitherBoolFalsy<GenericValue>;
 type Either = EitherRight | EitherLeft;
 export declare function isBoolFalsy<GenericInput extends unknown>(input: GenericInput): input is Extract<GenericInput, EitherBoolFalsy>;
 type ToEither<GenericValue extends unknown> = GenericValue extends Either ? GenericValue : ReturnType<typeof bool<GenericValue>>;

package/dist/index.cjs

@@ -54,6 +54,10 @@ var createKindIdentifier = require('./common/createKindIdentifier.cjs');
 var forwardLog = require('./common/forwardLog.cjs');
 var override = require('./common/override.cjs');
 var errorKindNamespace = require('./common/errorKindNamespace.cjs');
+var truthy = require('./common/truthy.cjs');
+var falsy = require('./common/falsy.cjs');
+var hasSomeKinds = require('./common/hasSomeKinds.cjs');
+var hasKinds = require('./common/hasKinds.cjs');
 
 
 
@@ -135,3 +139,7 @@ exports.createKindIdentifier = createKindIdentifier.createKindIdentifier;
 exports.forwardLog = forwardLog.forwardLog;
 exports.createOverride = override.createOverride;
 exports.createErrorKind = errorKindNamespace.createErrorKind;
+exports.truthy = truthy.truthy;
+exports.falsy = falsy.falsy;
+exports.hasSomeKinds = hasSomeKinds.hasSomeKinds;
+exports.hasKinds = hasKinds.hasKinds;

package/dist/index.mjs

@@ -76,3 +76,7 @@ export { createKindIdentifier } from './common/createKindIdentifier.mjs';
 export { forwardLog } from './common/forwardLog.mjs';
 export { createOverride } from './common/override.mjs';
 export { createErrorKind } from './common/errorKindNamespace.mjs';
+export { truthy } from './common/truthy.mjs';
+export { falsy } from './common/falsy.mjs';
+export { hasSomeKinds } from './common/hasSomeKinds.mjs';
+export { hasKinds } from './common/hasKinds.mjs';

package/dist/metadata.json

@@ -976,6 +976,9 @@
             {
               "name": "expectType.d.ts"
             },
+            {
+              "name": "falsyValue.d.ts"
+            },
             {
               "name": "fixDeepFunctionInfer.d.ts"
             },
@@ -1197,6 +1200,15 @@
         {
           "name": "externalPromise.mjs"
         },
+        {
+          "name": "falsy.cjs"
+        },
+        {
+          "name": "falsy.d.ts"
+        },
+        {
+          "name": "falsy.mjs"
+        },
         {
           "name": "forward.cjs"
         },
@@ -1224,6 +1236,24 @@
         {
           "name": "globalStore.mjs"
         },
+        {
+          "name": "hasKinds.cjs"
+        },
+        {
+          "name": "hasKinds.d.ts"
+        },
+        {
+          "name": "hasKinds.mjs"
+        },
+        {
+          "name": "hasSomeKinds.cjs"
+        },
+        {
+          "name": "hasSomeKinds.d.ts"
+        },
+        {
+          "name": "hasSomeKinds.mjs"
+        },
         {
           "name": "index.d.ts"
         },
@@ -1407,6 +1437,15 @@
         {
           "name": "toWrappedValue.mjs"
         },
+        {
+          "name": "truthy.cjs"
+        },
+        {
+          "name": "truthy.d.ts"
+        },
+        {
+          "name": "truthy.mjs"
+        },
         {
           "name": "unwrap.cjs"
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.3.27",
+  "version": "1.3.29",
   "author": {
     "name": "mathcovax",
     "url": "https://github.com/mathcovax"