@duplojs/utils 1.0.5 → 1.0.7

package/dist/index.mjs

@@ -29,6 +29,10 @@ export { whenNot } from './common/whenNot.mjs';
 export { equal } from './common/equal.mjs';
 export { not } from './common/not.mjs';
 export { isType } from './common/isType.mjs';
+export { and } from './common/and.mjs';
+export { or } from './common/or.mjs';
+export { whenElse } from './common/whenElse.mjs';
+export { justReturn } from './common/justReturn.mjs';
 import * as index from './array/index.mjs';
 export { index as A };
 export { index as DArray };

package/dist/object/discriminate.d.ts

@@ -1,8 +1,7 @@
 import { type EligibleEqual, type MaybeArray } from "../common";
-import { type GetPropsWithValueExtends } from "./types/getPropsWithValueExtends";
-export declare function discriminate<GenericInput extends object, GenericKey extends GetPropsWithValueExtends<GenericInput, EligibleEqual>, GenericValue extends EligibleEqual>(key: GenericKey, value: (MaybeArray<(GenericValue & GenericInput[GenericKey])> | MaybeArray<GenericInput[GenericKey]>)): (input: GenericInput) => input is Extract<GenericInput, {
+export declare function discriminate<GenericInput extends object, GenericKey extends keyof GenericInput, GenericValue extends EligibleEqual>(key: GenericKey, value: (MaybeArray<(GenericValue & Extract<GenericInput[GenericKey], EligibleEqual>)> | MaybeArray<Extract<GenericInput[GenericKey], EligibleEqual>>)): (input: GenericInput) => input is Extract<GenericInput, {
     [Prop in GenericKey]: GenericValue;
 }>;
-export declare function discriminate<GenericInput extends object, GenericKey extends GetPropsWithValueExtends<GenericInput, EligibleEqual>, GenericValue extends EligibleEqual>(input: GenericInput, key: GenericKey, value: (MaybeArray<(GenericValue & GenericInput[GenericKey])> | MaybeArray<GenericInput[GenericKey]>)): input is Extract<GenericInput, {
+export declare function discriminate<GenericInput extends object, GenericKey extends keyof GenericInput, GenericValue extends EligibleEqual>(input: GenericInput, key: GenericKey, value: (MaybeArray<(GenericValue & Extract<GenericInput[GenericKey], EligibleEqual>)> | MaybeArray<Extract<GenericInput[GenericKey], EligibleEqual>>)): input is Extract<GenericInput, {
     [Prop in GenericKey]: GenericValue;
 }>;

package/dist/object/entry.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+function entry(key, value) {
+    return [key, value];
+}
+
+exports.entry = entry;

package/dist/object/entry.d.ts

@@ -0,0 +1,2 @@
+import { type AnyValue, type ObjectKey } from "../common";
+export declare function entry<GenericKey extends ObjectKey, GenericValue extends AnyValue>(key: GenericKey, value: GenericValue): readonly [GenericKey, GenericValue];

package/dist/object/entry.mjs

@@ -0,0 +1,5 @@
+function entry(key, value) {
+    return [key, value];
+}
+
+export { entry };

package/dist/object/index.cjs

@@ -16,6 +16,7 @@ var pick = require('./pick.cjs');
 var deepDiscriminate = require('./deepDiscriminate.cjs');
 var getDeepProperty = require('./getDeepProperty.cjs');
 var discriminate = require('./discriminate.cjs');
+var entry = require('./entry.cjs');
 
 
 
@@ -35,3 +36,4 @@ exports.pick = pick.pick;
 exports.deepDiscriminate = deepDiscriminate.deepDiscriminate;
 exports.getDeepProperty = getDeepProperty.getDeepProperty;
 exports.discriminate = discriminate.discriminate;
+exports.entry = entry.entry;

package/dist/object/index.d.ts

@@ -15,3 +15,4 @@ export * from "./pick";
 export * from "./deepDiscriminate";
 export * from "./getDeepProperty";
 export * from "./discriminate";
+export * from "./entry";

package/dist/object/index.mjs

@@ -14,3 +14,4 @@ export { pick } from './pick.mjs';
 export { deepDiscriminate } from './deepDiscriminate.mjs';
 export { getDeepProperty } from './getDeepProperty.mjs';
 export { discriminate } from './discriminate.mjs';
+export { entry } from './entry.mjs';

package/dist/object/keys.cjs

@@ -1,7 +1,10 @@
 'use strict';
 
+var wrapValue = require('../common/wrapValue.cjs');
+
 function keys(object) {
-    return Object.keys(object);
+    return Object.keys(object)
+        .filter((key) => !key.startsWith(wrapValue.keyWrappedValue));
 }
 
 exports.keys = keys;

package/dist/object/keys.d.ts

@@ -1 +1 @@
-export declare function keys<GenericObject extends object>(object: GenericObject): (keyof GenericObject)[];
+export declare function keys<GenericObject extends object>(object: GenericObject): (Exclude<keyof GenericObject, symbol>)[];

package/dist/object/keys.mjs

@@ -1,5 +1,8 @@
+import { keyWrappedValue } from '../common/wrapValue.mjs';
+
 function keys(object) {
-    return Object.keys(object);
+    return Object.keys(object)
+        .filter((key) => !key.startsWith(keyWrappedValue));
 }
 
 export { keys };

package/dist/pattern/result.d.ts

@@ -1,6 +1,6 @@
 import { type Kind, type WrappedValue } from "../common";
 declare const patternResultKind: import("../common").KindHandler<import("../common").KindDefinition<"pattern-result", unknown>>;
-export interface PatternResult<GenericValue extends unknown = unknown> extends Kind<typeof patternResultKind.definition>, WrappedValue<GenericValue> {
+export interface PatternResult<GenericValue extends unknown = any> extends Kind<typeof patternResultKind.definition>, WrappedValue<GenericValue> {
 }
 export declare function result<const GenericValue extends unknown>(value: GenericValue): PatternResult<GenericValue>;
 export declare const isResult: <GenericInput extends unknown>(input: GenericInput) => input is Extract<GenericInput, Kind<import("../common").KindDefinition<"pattern-result", unknown>, unknown>>;

package/dist/pattern/when.d.ts

@@ -1,6 +1,6 @@
-import { type AnyValue } from "../common";
+import { type AnyValue, type BreakGenericLink } from "../common";
 import { type PatternResult } from "./result";
-export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult<GenericOutput>);
+export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | Exclude<BreakGenericLink<GenericInputValue>, GenericPredicatedInput> | PatternResult<GenericOutput>);
 export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (input: (GenericInput | GenericInputPatternResult | GenericInputValue)) => (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);
 export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericPredicatedInput extends GenericInputValue, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => input is GenericPredicatedInput, theFunction: (predicatedInput: GenericPredicatedInput) => GenericOutput): (GenericInputPatternResult | Exclude<GenericInputValue, GenericPredicatedInput> | PatternResult<GenericOutput>);
 export declare function when<GenericInput extends AnyValue, GenericInputValue extends Exclude<GenericInput, PatternResult>, GenericInputPatternResult extends Extract<GenericInput, PatternResult>, GenericOutput extends AnyValue>(input: (GenericInput | GenericInputPatternResult | GenericInputValue), predicate: (input: GenericInputValue) => boolean, theFunction: (predicatedInput: GenericInputValue) => GenericOutput): (GenericInputPatternResult | GenericInputValue | PatternResult<GenericOutput>);

package/dist/string/index.cjs

@@ -32,6 +32,7 @@ var repeat = require('./repeat.cjs');
 var normalize = require('./normalize.cjs');
 var test = require('./test.cjs');
 var isIn = require('./isIn.cjs');
+var length = require('./length.cjs');
 
 
 
@@ -67,3 +68,4 @@ exports.repeat = repeat.repeat;
 exports.normalize = normalize.normalize;
 exports.test = test.test;
 exports.isIn = isIn.isIn;
+exports.length = length.length;

package/dist/string/index.d.ts

@@ -27,3 +27,4 @@ export * from "./repeat";
 export * from "./normalize";
 export * from "./test";
 export * from "./isIn";
+export * from "./length";

package/dist/string/index.mjs

@@ -30,3 +30,4 @@ export { repeat } from './repeat.mjs';
 export { normalize } from './normalize.mjs';
 export { test } from './test.mjs';
 export { isIn } from './isIn.mjs';
+export { length } from './length.mjs';

package/dist/string/length.cjs

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

package/dist/string/length.d.ts

@@ -0,0 +1,2 @@
+import { type StringLength } from "./types/stringLength";
+export declare function length<GenericInput extends string>(input: GenericInput): StringLength<GenericInput>;

package/dist/string/length.mjs

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

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

@@ -5,3 +5,4 @@ export * from "./endsWith";
 export * from "./startsWith";
 export * from "./normalizeForm";
 export * from "./split";
+export * from "./stringLength";

package/dist/string/types/stringLength.d.ts

@@ -0,0 +1,2 @@
+import { type Split } from "./split";
+export type StringLength<GenericString extends string> = Split<GenericString, "">["length"];

package/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",
-  "repository": "https://github.com/duplojs/utils",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/duplojs/utils.git"
+  },
   "scripts": {
     "build": "rollup --config && tsc-alias -p tsconfig.build.json",
     "test:tu": "vitest --coverage",
@@ -46,7 +49,9 @@
     "vite-tsconfig-paths": "5.1.4",
     "vitest": "3.2.4"
   },
-  "workspaces": ["integration"],
+  "workspaces": [
+    "integration"
+  ],
   "keywords": [],
   "engines": {
     "node": ">=22.15.1"