@duplojs/lang 0.0.1-beta.2 → 0.0.1-beta.4

package/dist/invocation/flow/controller/defaults/aborter.d.ts

@@ -1,14 +1,17 @@
 import { FlowController } from '../base';
-import type * as DCommon from '../../../../common';
+import * as DCommon from '../../../../common';
 import * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerAborterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-aborter", unknown>>;
-export interface FlowControllerAborter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<Awaited<GenericOutput> | DEither.Left<"signal-aborted", AbortErrorFlowController>>> & DKind.Kind<typeof flowControllerAborterKind>> {
+export interface FlowControllerAborter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<Awaited<GenericOutput> | DEither.Left<"signal-aborted", AbortErrorFlowController>>> & DKind.Kind<typeof flowControllerAborterKind>> {
 }
 declare const AbortErrorFlowController_base: DKind.KindClass<DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/abort-error-flow-controller", unknown>>, ErrorConstructor>;
 export declare class AbortErrorFlowController extends AbortErrorFlowController_base {
     abortController: AbortController;
     constructor(abortController: AbortController);
 }
-export declare const aborter: <GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: GenericInput, aborter: AbortController) => GenericOutput) => FlowControllerAborter<GenericInput, GenericOutput>;
+export interface FlowControllerAborterParams {
+    timeout?: DCommon.TimeInString;
+}
+export declare const aborter: <GenericInput extends unknown, GenericOutput extends unknown>(theFunction: (input: GenericInput, aborter: AbortController) => GenericOutput, params?: FlowControllerAborterParams) => FlowControllerAborter<GenericInput, GenericOutput>;
 export {};

package/dist/invocation/flow/controller/defaults/aborter.mjs

@@ -1,5 +1,6 @@
 import { parentClass } from "../../../../kind/parentClass.mjs";
 import { left } from "../../../../either/left/create.mjs";
+import { stringToMillisecond } from "../../../../common/stringToMillisecond.mjs";
 import { createKind } from "../../../kind.mjs";
 import { createFlowController, flowControllerExitKind } from "../base.mjs";
 //#region scripts/invocation/flow/controller/defaults/aborter.ts
@@ -11,14 +12,16 @@ var AbortErrorFlowController = class extends parentClass(createKind("abort-error
 		this.abortController = abortController;
 	}
 };
-const aborter = createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction) => {
+const aborter = createFlowController(flowControllerAborterKind, ({ init, exitFlow }) => (theFunction, params) => {
 	let aborter = void 0;
+	const formattedTimeout = params?.timeout === void 0 ? void 0 : stringToMillisecond(params.timeout);
 	return init(async (previousFunction) => {
 		const result = previousFunction();
 		if (flowControllerExitKind.has(result)) return result;
 		aborter?.abort(new AbortErrorFlowController(aborter));
 		const currentAborter = new AbortController();
 		aborter = currentAborter;
+		if (formattedTimeout !== void 0) setTimeout(() => void currentAborter.abort(new AbortErrorFlowController(currentAborter)), formattedTimeout);
 		try {
 			const abortResult = await theFunction(result, currentAborter);
 			if (currentAborter.signal.aborted === true) return exitFlow(left("signal-aborted", currentAborter.signal.reason));

package/dist/invocation/flow/controller/defaults/debounce.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerDebounceKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-debounce", unknown>>;
-export interface FlowControllerDebounce<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"debounce-reject">>>> & DKind.Kind<typeof flowControllerDebounceKind>> {
+export interface FlowControllerDebounce<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"debounce-reject">>>> & DKind.Kind<typeof flowControllerDebounceKind>> {
 }
 export declare const debounce: <GenericInput extends unknown = unknown>(debounce: DCommon.TimeInString) => FlowControllerDebounce<GenericInput>;

package/dist/invocation/flow/controller/defaults/filter.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerFilterKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-filter", unknown>>;
-export interface FlowControllerFilter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, DCommon.SplitPromise<GenericOutput> extends infer InferredOutput ? InferredOutput extends unknown ? Awaited<InferredOutput> extends infer InferredAwaited ? (InferredAwaited extends DEither.Left ? FlowControllerExit<InferredAwaited> : InferredAwaited extends DEither.Right ? DEither.GetValue<InferredAwaited> : InferredAwaited) extends infer InferredResult ? InferredOutput extends Promise<unknown> ? Promise<InferredResult> : InferredResult : never : never : never : never> & DKind.Kind<typeof flowControllerFilterKind>> {
+export interface FlowControllerFilter<GenericInput extends unknown = unknown, GenericOutput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, DCommon.SplitPromise<GenericOutput> extends infer InferredOutput ? InferredOutput extends unknown ? Awaited<InferredOutput> extends infer InferredAwaited ? (InferredAwaited extends DEither.Left ? FlowControllerExit<InferredAwaited> : InferredAwaited extends DEither.Right ? DEither.GetValue<InferredAwaited> : InferredAwaited) extends infer InferredResult ? InferredOutput extends Promise<unknown> ? Promise<InferredResult> : InferredResult : never : never : never : never> & DKind.Kind<typeof flowControllerFilterKind>> {
 }
 export declare const filter: <GenericInput extends unknown, GenericOutput extends unknown>(filterFunction: (input: GenericInput) => GenericOutput) => FlowControllerFilter<GenericInput, GenericOutput>;

package/dist/invocation/flow/controller/defaults/retry.d.ts

@@ -2,7 +2,7 @@ import { FlowController } from '../base';
 import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 export declare const flowControllerRetryKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-retry", unknown>>;
-export interface FlowControllerRetry<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerRetryKind>> {
+export interface FlowControllerRetry<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerRetryKind>> {
 }
 export interface RetryParams {
     times?: number;

package/dist/invocation/flow/controller/defaults/throttling.d.ts

@@ -3,6 +3,6 @@ import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 import * as DEither from '../../../../either';
 export declare const flowControllerThrottlingKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-throttling", unknown>>;
-export interface FlowControllerThrottling<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"throttling-reject">>>> & DKind.Kind<typeof flowControllerThrottlingKind>> {
+export interface FlowControllerThrottling<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<FlowControllerExit<DEither.Left<"throttling-reject">>>> & DKind.Kind<typeof flowControllerThrottlingKind>> {
 }
 export declare const throttling: <GenericInput extends unknown = unknown>(throttling: DCommon.TimeInString) => FlowControllerThrottling<GenericInput>;

package/dist/invocation/flow/controller/defaults/timeout.d.ts

@@ -2,6 +2,6 @@ import { FlowController } from '../base';
 import * as DCommon from '../../../../common';
 import type * as DKind from '../../../../kind';
 export declare const flowControllerTimeoutKind: DKind.Handler<DKind.Definition<"@DuplojsLangInvocation/flow-controller-timeout", unknown>>;
-export interface FlowControllerTimeout<GenericInput extends unknown = unknown> extends DCommon.UnionToIntersection<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerTimeoutKind>> {
+export interface FlowControllerTimeout<GenericInput extends unknown = unknown> extends DCommon.Forward<FlowController<GenericInput, Promise<never>> & DKind.Kind<typeof flowControllerTimeoutKind>> {
 }
 export declare const timeout: <GenericInput extends unknown = unknown>(timeout: DCommon.TimeInString) => FlowControllerTimeout<GenericInput>;

package/dist/kind/createIdentifier.d.ts

@@ -1,7 +1,11 @@
 import { Kind, Handler } from './base';
 import { GetHandler } from './types';
 import type * as DCommon from '../common';
-export declare function createKindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent>(): {
-    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
-    <GenericKindHandler extends GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never, GenericInput extends unknown, GenericGroupedKind extends DCommon.UnionToIntersection<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is ((DCommon.UnionContain<GenericInput, GenericParent> extends true ? Extract<GenericChildren, GenericGroupedKind> : never) | Extract<GenericInput, GenericGroupedKind>);
-};
+type KindIdentifierHandlers<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent> = GenericChildren extends infer InferredChildren ? InferredChildren extends GenericParent ? GetHandler<InferredChildren> : never : never;
+type KindIdentifierResult<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent, GenericInput extends unknown, GenericGroupedKind extends unknown> = ((GenericInput extends GenericParent ? GenericChildren extends GenericInput ? GenericChildren extends GenericGroupedKind ? GenericChildren : never : never : never) | Extract<GenericInput, GenericGroupedKind>);
+export interface KindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent> {
+    <GenericKindHandler extends KindIdentifierHandlers<GenericParent, GenericChildren>, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(kind: GenericKindHandler | GenericKindHandler[]): (input: GenericInput) => input is KindIdentifierResult<GenericParent, GenericChildren, GenericInput, GenericGroupedKind>;
+    <GenericKindHandler extends KindIdentifierHandlers<GenericParent, GenericChildren>, GenericInput extends unknown, GenericGroupedKind extends DCommon.Forward<GenericKindHandler extends Handler ? Kind<GenericKindHandler> : never>>(input: GenericInput, kind: GenericKindHandler | GenericKindHandler[]): input is KindIdentifierResult<GenericParent, GenericChildren, GenericInput, GenericGroupedKind>;
+}
+export declare function createKindIdentifier<GenericParent extends Kind<Handler>, GenericChildren extends GenericParent>(): KindIdentifier<GenericParent, GenericChildren>;
+export {};

package/dist/modeling/entity/base.d.ts

@@ -1,4 +1,3 @@
-import { Codecs, EncodedValue } from '../../dataStructure/common';
 import { NewType, NewTypeMap } from '../newType';
 import type * as DKind from '../../kind';
 import * as DCommon from '../../common';
@@ -10,9 +9,9 @@ declare module '../../dataStructure' {
     }
 }
 declare module '../../dataStructure/common' {
-    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends Codecs> {
+    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
         entity: GenericValue extends Entity<infer InferredName> ? (Entity<InferredName> & {
-            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: EncodedValue<GenericValue[Prop], GenericCodecs>;
+            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
         }) : never;
     }
 }
@@ -34,7 +33,7 @@ export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.Re
 ]> extends true ? {
     [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
-export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.UnionToIntersection<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
+export interface EntityStructure<GenericName extends string = string, GenericProperties extends Record<string, unknown> = Record<string, unknown>> extends DCommon.Forward<DDataStructure.Structure<Entity<GenericName> & GenericProperties, EntityStructureDefinition> & DKind.Kind<typeof entityStructureKind>> {
     readonly name: GenericName;
     "new"<GenericNewProperties extends GenericProperties>(properties: GenericNewProperties): (Entity<GenericName> & GenericNewProperties);
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<EntityMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);

package/dist/modeling/newType/base.d.ts

@@ -25,7 +25,7 @@ export interface NewTypeStructureDefinition<GenericNewTypeConstraint extends rea
     readonly newTypeConstraints: GenericNewTypeConstraint;
 }
 export type ComputeNewType<GenericName extends string, GenericValue extends unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[], GenericIntersectionConstraintValue = DDataStructure.ConstraintValue<DArray.Unwrap<GenericNewTypeConstraint>>, GenericClearValue = DCommon.NeverCoalescing<DCommon.RemoveConstraint<GenericIntersectionConstraintValue>, unknown>> = (GenericValue & GenericClearValue & NewType<GenericName, GenericIntersectionConstraintValue extends (GenericClearValue & infer InferredConstraint extends DCommon.BaseConstraint) ? InferredConstraint : never>);
-export interface NewTypeStructure<GenericName extends string = string, GenericValue extends unknown = unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[] = readonly DDataStructure.Constraint<GenericValue>[]> extends DCommon.UnionToIntersection<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
+export interface NewTypeStructure<GenericName extends string = string, GenericValue extends unknown = unknown, GenericNewTypeConstraint extends readonly DDataStructure.Constraint<GenericValue>[] = readonly DDataStructure.Constraint<GenericValue>[]> extends DCommon.Forward<DDataStructure.Structure<ComputeNewType<GenericName, GenericValue, GenericNewTypeConstraint>, NewTypeStructureDefinition<GenericNewTypeConstraint>> & DKind.Kind<typeof newTypeStructureKind>> {
     readonly name: GenericName;
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>) => (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
     decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<NewTypeMap<DDataStructure.StructureValue<this>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);

package/dist/modeling/taggedObject/base.d.ts

@@ -1,4 +1,3 @@
-import { Codecs, EncodedValue } from '../../dataStructure/common';
 import type * as DKind from '../../kind';
 import type * as DCommon from '../../common';
 import * as DDataStructure from '../../dataStructure';
@@ -8,9 +7,9 @@ declare module '../../dataStructure' {
     }
 }
 declare module '../../dataStructure/common' {
-    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends Codecs> {
+    interface EncodeStructure<GenericValue extends unknown, GenericCodecs extends DDataStructure.Codecs> {
         taggedObject: GenericValue extends ObjectTag<infer InferredName> ? (ObjectTag<InferredName> & {
-            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: EncodedValue<GenericValue[Prop], GenericCodecs>;
+            [Prop in Exclude<keyof GenericValue, DKind.KeySymbol>]: DDataStructure.EncodedValue<GenericValue[Prop], GenericCodecs>;
         }) : never;
     }
 }
@@ -26,7 +25,7 @@ export declare const taggedObjectStructureKind: DKind.Handler<DKind.Definition<"
 export interface TaggedObjectStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DDataStructure.ObjectStructure;
 }
-export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.UnionToIntersection<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
+export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
     readonly name: GetTagValue<GenericTaggedObject>;
 }
 export declare const TaggedObjectStructure: <GenericTaggedObject extends ObjectTag, GenericName extends string = never, GenericShape extends DDataStructure.ShapeObjectStructure = never>(name: GetTagValue<GenericTaggedObject> | GenericName, shape: ShapeTaggedObjectStructure<GenericTaggedObject> | GenericShape) => TaggedObjectStructure<ObjectTag extends GenericTaggedObject ? (ObjectTag<GenericName> & DDataStructure.ShapeObjectStructureValue<GenericShape>) : GenericTaggedObject>;

package/dist/string/isUrl.cjs

@@ -1,16 +1,7 @@
 //#region scripts/string/isUrl.ts
-const regexRemoveDote = /:$/;
-function isUrl(string, params) {
+function isUrl(string) {
 	try {
-		const url = new URL(string);
-		if (params?.hostname) {
-			params.hostname.lastIndex = 0;
-			if (!params.hostname.test(url.hostname)) return false;
-		}
-		if (params?.protocol) {
-			params.protocol.lastIndex = 0;
-			if (!params.protocol.test(url.protocol.replace(regexRemoveDote, ""))) return false;
-		}
+		new URL(string);
 		return true;
 	} catch {
 		return false;

package/dist/string/isUrl.d.ts

@@ -1,6 +1,2 @@
 import { Url } from './constraints';
-export interface IsUrlParams {
-    hostname?: RegExp;
-    protocol?: RegExp;
-}
-export declare function isUrl<GenericValue extends string>(string: GenericValue, params?: IsUrlParams): string is GenericValue & Url;
+export declare function isUrl<GenericValue extends string>(string: GenericValue): string is GenericValue & Url;

package/dist/string/isUrl.mjs

@@ -1,16 +1,7 @@
 //#region scripts/string/isUrl.ts
-const regexRemoveDote = /:$/;
-function isUrl(string, params) {
+function isUrl(string) {
 	try {
-		const url = new URL(string);
-		if (params?.hostname) {
-			params.hostname.lastIndex = 0;
-			if (!params.hostname.test(url.hostname)) return false;
-		}
-		if (params?.protocol) {
-			params.protocol.lastIndex = 0;
-			if (!params.protocol.test(url.protocol.replace(regexRemoveDote, ""))) return false;
-		}
+		new URL(string);
 		return true;
 	} catch {
 		return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@duplojs/lang",
-  "version": "0.0.1-beta.2",
+  "version": "0.0.1-beta.4",
   "license": "MIT",
   "type": "module",
   "author": {