@duplojs/utils 1.1.15 → 1.1.16

package/dist/dataParser/extended/lazy.d.ts

@@ -1,4 +1,4 @@
-import { type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
+import { type Memoized, type FixDeepFunctionInfer, type NeverCoalescing } from "../../common";
 import { type DataParserExtended } from "../baseExtended";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../types";
 import * as dataParsers from "../parsers";
@@ -17,6 +17,6 @@ export interface DataParserLazyExtended<GenericDefinition extends dataParsers.Da
     ]>>;
 }
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<dataParsers.DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazyExtended<MergeDefinition<dataParsers.DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
-    getter(): GenericDataParser;
+    getter: Memoized<GenericDataParser>;
 }>>;
 export {};

package/dist/dataParser/parsers/lazy.cjs

@@ -1,5 +1,8 @@
 'use strict';
 
+var memo = require('../../common/memo.cjs');
+require('../../common/globalStore.cjs');
+require('../../common/builder.cjs');
 var base = require('../base.cjs');
 var kind = require('../kind.cjs');
 
@@ -9,11 +12,11 @@ function lazy(getter, definition) {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
-            getter,
+            getter: memo.memo(getter),
         },
     }, {
-        sync: (data, _error, self) => self.definition.getter().exec(data, _error),
-        async: (data, _error, self) => self.definition.getter().asyncExec(data, _error),
+        sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
+        async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
     });
 }
 

package/dist/dataParser/parsers/lazy.d.ts

@@ -1,4 +1,4 @@
-import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer } from "../../common";
+import { type NeverCoalescing, type Kind, type FixDeepFunctionInfer, type Memoized } from "../../common";
 import { type DataParserDefinition, type DataParser, type Output, type Input, type DataParserChecker } from "../base";
 import { type AddCheckersToDefinition, type MergeDefinition } from "../../dataParser/types";
 import { type CheckerRefineImplementation } from "./refine";
@@ -7,10 +7,10 @@ export interface DataParserLazyCheckerCustom<GenericInput extends unknown = unkn
 }
 export type DataParserLazyCheckers<GenericInput extends unknown = unknown> = (DataParserLazyCheckerCustom<GenericInput>[GetPropsWithValueExtends<DataParserLazyCheckerCustom<GenericInput>, DataParserChecker>] | CheckerRefineImplementation<GenericInput>);
 export interface DataParserDefinitionLazy extends DataParserDefinition<DataParserLazyCheckers> {
-    getter(): DataParser;
+    getter: Memoized<DataParser>;
 }
 export declare const lazyKind: import("../../common").KindHandler<import("../../common").KindDefinition<"@DuplojsUtilsDataParser/lazy", unknown>>;
-type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<ReturnType<GenericDefinition["getter"]>>, Input<ReturnType<GenericDefinition["getter"]>>> & Kind<typeof lazyKind.definition>);
+type _DataParserLazy<GenericDefinition extends DataParserDefinitionLazy> = (DataParser<GenericDefinition, Output<GenericDefinition["getter"]["value"]>, Input<GenericDefinition["getter"]["value"]>> & Kind<typeof lazyKind.definition>);
 export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLazy = DataParserDefinitionLazy> extends _DataParserLazy<GenericDefinition> {
     addChecker<GenericChecker extends readonly [
         DataParserLazyCheckers<Output<this>>,
@@ -21,6 +21,6 @@ export interface DataParserLazy<GenericDefinition extends DataParserDefinitionLa
     ], GenericChecker>): DataParserLazy<AddCheckersToDefinition<GenericDefinition, GenericChecker>>;
 }
 export declare function lazy<GenericDataParser extends DataParser, const GenericDefinition extends Partial<DataParserDefinitionLazy> = never>(getter: () => GenericDataParser, definition?: GenericDefinition): DataParserLazy<MergeDefinition<DataParserDefinitionLazy, NeverCoalescing<GenericDefinition, {}> & {
-    getter(): GenericDataParser;
+    getter: Memoized<GenericDataParser>;
 }>>;
 export {};

package/dist/dataParser/parsers/lazy.mjs

@@ -1,3 +1,6 @@
+import { memo } from '../../common/memo.mjs';
+import '../../common/globalStore.mjs';
+import '../../common/builder.mjs';
 import { dataParserInit } from '../base.mjs';
 import { createDataParserKind } from '../kind.mjs';
 
@@ -7,11 +10,11 @@ function lazy(getter, definition) {
         definition: {
             errorMessage: definition?.errorMessage,
             checkers: definition?.checkers ?? [],
-            getter,
+            getter: memo(getter),
         },
     }, {
-        sync: (data, _error, self) => self.definition.getter().exec(data, _error),
-        async: (data, _error, self) => self.definition.getter().asyncExec(data, _error),
+        sync: (data, _error, self) => self.definition.getter.value.exec(data, _error),
+        async: (data, _error, self) => self.definition.getter.value.asyncExec(data, _error),
     });
 }
 

package/dist/either/hasInformation.cjs

@@ -2,7 +2,12 @@
 
 var kind = require('./kind.cjs');
 
-function hasInformation(input, information) {
+function hasInformation(...args) {
+    if (args.length === 1) {
+        const [information] = args;
+        return (input) => hasInformation(input, information);
+    }
+    const [input, information] = args;
     return kind.eitherInformationKind.has(input)
         && kind.eitherInformationKind.getValue(input) === information;
 }

package/dist/either/hasInformation.d.ts

@@ -3,5 +3,6 @@ import { type EitherLeft } from "./left";
 import { type EitherRight } from "./right";
 import { eitherInformationKind } from "./kind";
 type Either = EitherRight | EitherLeft;
+export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(information: GenericInformation): (input: GenericInput) => input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
 export declare function hasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never)>(input: GenericInput, information: GenericInformation): input is Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
 export {};

package/dist/either/hasInformation.mjs

@@ -1,6 +1,11 @@
 import { eitherInformationKind } from './kind.mjs';
 
-function hasInformation(input, information) {
+function hasInformation(...args) {
+    if (args.length === 1) {
+        const [information] = args;
+        return (input) => hasInformation(input, information);
+    }
+    const [input, information] = args;
     return eitherInformationKind.has(input)
         && eitherInformationKind.getValue(input) === information;
 }

package/dist/either/whenHasInformation.d.ts

@@ -3,6 +3,6 @@ import { type EitherRight } from "./right";
 import { type EitherLeft } from "./left";
 import { eitherInformationKind } from "./kind";
 type Either = EitherRight | EitherLeft;
-export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
-export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(input: GenericInput, information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): GenericOutput | Exclude<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): (input: GenericInput) => GenericOutput | Exclude<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
+export declare function whenHasInformation<const GenericInput extends unknown, GenericInformation extends (GenericInput extends Either ? ReturnType<typeof eitherInformationKind.getValue<GenericInput>> : never), const GenericOutput extends AnyValue>(input: GenericInput, information: GenericInformation | GenericInformation[], theFunction: (value: Unwrap<Extract<BreakGenericLink<GenericInput>, Kind<typeof eitherInformationKind.definition, GenericInformation> & WrappedValue>>) => GenericOutput): GenericOutput | Exclude<GenericInput, Kind<typeof eitherInformationKind.definition, GenericInformation>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/utils",
-  "version": "1.1.15",
+  "version": "1.1.16",
   "author": "mathcovax",
   "license": "MIT",
   "type": "module",