@duplojs/lang 0.0.1-beta.6 → 0.0.1-beta.7

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

@@ -1,4 +1,4 @@
 import { MaybeArray } from './maybeArray';
 export type Json = MaybeArray<string | undefined | boolean | number | null | {
-    [key: string]: Json;
+    readonly [key: string]: Json;
 }>;

package/dist/dataStructure/constraint/base.cjs

@@ -1,9 +1,24 @@
+const require_bindPrototypeMethods = require("../../common/bindPrototypeMethods.cjs");
 const require_simpleClone = require("../../common/simpleClone.cjs");
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = require("../kind.cjs").createKind("constraint");
+var ConstraintBase = class ConstraintBase {
+	constructor() {}
+	static init(params) {
+		const self = new ConstraintBase();
+		require_bindPrototypeMethods.bindPrototypeMethods(self);
+		for (const key in params) self[key] = params[key];
+		return self;
+	}
+	static addToPrototype(prop, value) {
+		ConstraintBase.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
+	}
+};
 function createConstraint(kindHandler, createConstructor) {
 	const init = (definition, { executeCheck, isAsynchronous }) => {
-		const self = {
+		const self = ConstraintBase.init({
 			definition,
 			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
@@ -20,11 +35,12 @@ function createConstraint(kindHandler, createConstructor) {
 			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
-		};
+		});
 		return self;
 	};
 	return createConstructor({ init });
 }
 //#endregion
+exports.ConstraintBase = ConstraintBase;
 exports.constraintKind = constraintKind;
 exports.createConstraint = createConstraint;

package/dist/dataStructure/constraint/base.d.ts

@@ -19,6 +19,11 @@ export interface CreateConstraintInitParams<GenericConstraint extends Constraint
     executeCheck(self: GenericConstraint, data: Parameters<GenericConstraint["executeCheck"]>[0]): DCommon.MaybePromise<SuccessSymbol | ErrorSymbol>;
     isAsynchronous(self: GenericConstraint): boolean;
 }
+export declare class ConstraintBase {
+    private constructor();
+    static init(params: DKind.Remove<Constraint>): Constraint;
+    static addToPrototype<GenericProp extends keyof Constraint>(prop: GenericProp, value: Constraint[GenericProp] extends infer InferredValue ? InferredValue extends DCommon.AnyFunction ? (self: Constraint, ...rest: Parameters<InferredValue>) => ReturnType<InferredValue> : Constraint[GenericProp] : never): void;
+}
 export interface CreateConstraintConstructorParams<GenericKindHandler extends DKind.Handler = DKind.Handler> {
     init<GenericConstraint extends (Constraint & DKind.Kind<GenericKindHandler>)>(definition: GenericConstraint["definition"], params: CreateConstraintInitParams<GenericConstraint>): GenericConstraint;
 }

package/dist/dataStructure/constraint/base.mjs

@@ -1,10 +1,25 @@
+import { bindPrototypeMethods } from "../../common/bindPrototypeMethods.mjs";
 import { simpleClone } from "../../common/simpleClone.mjs";
 import { createKind } from "../kind.mjs";
 //#region scripts/dataStructure/constraint/base.ts
 const constraintKind = createKind("constraint");
+var ConstraintBase = class ConstraintBase {
+	constructor() {}
+	static init(params) {
+		const self = new ConstraintBase();
+		bindPrototypeMethods(self);
+		for (const key in params) self[key] = params[key];
+		return self;
+	}
+	static addToPrototype(prop, value) {
+		ConstraintBase.prototype[prop] = typeof value === "function" ? function(...args) {
+			return value(this, ...args);
+		} : value;
+	}
+};
 function createConstraint(kindHandler, createConstructor) {
 	const init = (definition, { executeCheck, isAsynchronous }) => {
-		const self = {
+		const self = ConstraintBase.init({
 			definition,
 			executeCheck: (data) => executeCheck(self, data),
 			isAsynchronous: () => isAsynchronous(self),
@@ -21,10 +36,10 @@ function createConstraint(kindHandler, createConstructor) {
 			},
 			[constraintKind.runTimeKey]: null,
 			[kindHandler.runTimeKey]: null
-		};
+		});
 		return self;
 	};
 	return createConstructor({ init });
 }
 //#endregion
-export { constraintKind, createConstraint };
+export { ConstraintBase, constraintKind, createConstraint };

package/dist/dataStructure/index.cjs

@@ -138,6 +138,7 @@ var dataStructure_exports = /* @__PURE__ */ require_runtime.__exportAll({
 	BigintType: () => require_bigint$1.BigintType,
 	BooleanLiteralType: () => require_booleanLiteral.BooleanLiteralType,
 	BooleanType: () => require_boolean$1.BooleanType,
+	ConstraintBase: () => require_base.ConstraintBase,
 	DateType: () => require_date$1.DateType,
 	EmailConstraint: () => require_email.EmailConstraint,
 	ErrorSymbol: () => require_resultSymbol.ErrorSymbol,
@@ -340,6 +341,7 @@ exports.BigintLiteralType = require_bigintLiteral.BigintLiteralType;
 exports.BigintType = require_bigint$1.BigintType;
 exports.BooleanLiteralType = require_booleanLiteral.BooleanLiteralType;
 exports.BooleanType = require_boolean$1.BooleanType;
+exports.ConstraintBase = require_base.ConstraintBase;
 exports.DateType = require_date$1.DateType;
 exports.EmailConstraint = require_email.EmailConstraint;
 exports.ErrorSymbol = require_resultSymbol.ErrorSymbol;

package/dist/dataStructure/index.mjs

@@ -4,7 +4,7 @@ import { ErrorSymbol, SuccessSymbol } from "./common/resultSymbol.mjs";
 import { codecKind, codecsKind, createCodec, createCodecs } from "./common/codec.mjs";
 import { createErrorHandler, createGetErrorHandler, decodeIssueKind, encodeIssueKind, issueKind } from "./common/error.mjs";
 import { createErrorInterpreter } from "./common/errorInterpreter.mjs";
-import { constraintKind, createConstraint } from "./constraint/base.mjs";
+import { ConstraintBase, constraintKind, createConstraint } from "./constraint/base.mjs";
 import { AbsolutePathConstraint, absolutePathConstraintKind } from "./constraint/defaults/absolutePath.mjs";
 import { AllowedCharactersConstraint, allowedCharactersConstraintKind } from "./constraint/defaults/allowedCharacters.mjs";
 import { ArrayLengthEqualConstraint, arrayLengthEqualConstraintKind } from "./constraint/defaults/arrayLengthEqual.mjs";
@@ -138,6 +138,7 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	BigintType: () => BigintType,
 	BooleanLiteralType: () => BooleanLiteralType,
 	BooleanType: () => BooleanType,
+	ConstraintBase: () => ConstraintBase,
 	DateType: () => DateType,
 	EmailConstraint: () => EmailConstraint,
 	ErrorSymbol: () => ErrorSymbol,
@@ -330,4 +331,4 @@ var dataStructure_exports = /* @__PURE__ */ __exportAll({
 	uuidConstraintKind: () => uuidConstraintKind
 });
 //#endregion
-export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, SegmentPathConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsKind, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, segmentPath, segmentPathConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind };
+export { AbsolutePathConstraint, AllowedCharactersConstraint, ArrayLengthEqualConstraint, ArrayStructure, BetweenThanConstraint, BetweenThanOrEqualConstraint, BigintLiteralType, BigintType, BooleanLiteralType, BooleanType, ConstraintBase, DateType, EmailConstraint, ErrorSymbol, EvenConstraint, GreaterThanConstraint, GreaterThanOrEqualConstraint, IntegerConstraint, LazyStructure, LessThanConstraint, LessThanOrEqualConstraint, MaxCharactersConstraint, MaxElementsConstraint, MinCharactersConstraint, MinElementsConstraint, MultipleOfConstraint, NegativeConstraint, NonEncodableStringStructure, NotEmptyConstraint, NotZeroConstraint, NullType, NumberLiteralType, NumberType, ObjectStructure, OddConstraint, PathConstraint, PositiveConstraint, RecordStructure, RefineConstraint, RegexConstraint, SafeConstraint, SegmentPathConstraint, StrictNegativeConstraint, StrictPositiveConstraint, StringLengthEqualConstraint, StringLiteralType, StringType, StructureClass, SuccessSymbol, TheBigint, TheBoolean, TheDate, TheNull, TheNumber, TheString, TheTime, TheUndefined, TimeType, TrimmedConstraint, TypeStructure, UndefinedType, UnionStructure, UrlConstraint, UuidConstraint, absolutePath, absolutePathConstraintKind, allowedCharacters, allowedCharactersConstraintKind, array, arrayLengthEqual, arrayLengthEqualConstraintKind, arrayStructureKind, betweenThan, betweenThanConstraintKind, betweenThanOrEqual, betweenThanOrEqualConstraintKind, bigint, bigintFundamentalTypeKind, bigintLiteralTypeKind, bigintTypeKind, boolean, booleanFundamentalTypeKind, booleanLiteralTypeKind, booleanTypeKind, codecKind, codecsKind, constraintIdentifier, constraintKind, createCodec, createCodecs, createConstraint, createErrorHandler, createErrorInterpreter, createFundamentalType, createGetErrorHandler, createKind, createStructure, createType, dataStructure_exports, date, dateFundamentalTypeKind, dateTypeKind, decodeIssueKind, email, emailConstraintKind, encodeIssueKind, even, evenConstraintKind, extend, fundamentalTypeIdentifier, fundamentalTypeKind, greaterThan, greaterThanConstraintKind, greaterThanOrEqual, greaterThanOrEqualConstraintKind, integer, integerConstraintKind, isNullStructure, isUndefinedStructure, issueKind, lazy, lazyStructureKind, lessThan, lessThanConstraintKind, lessThanOrEqual, lessThanOrEqualConstraintKind, literal, maxCharacters, maxCharactersConstraintKind, maxElements, maxElementsConstraintKind, minCharacters, minCharactersConstraintKind, minElements, minElementsConstraintKind, multipleOf, multipleOfConstraintKind, negative, negativeConstraintKind, nonEncodableStringStructureKind, notEmpty, notEmptyConstraintKind, notZero, notZeroConstraintKind, nullHelper as null, nullFundamentalTypeKind, nullTypeKind, nullable, number, numberFundamentalTypeKind, numberLiteralTypeKind, numberTypeKind, object, objectStructureKind, odd, oddConstraintKind, optional, partial, path, pathConstraintKind, positive, positiveConstraintKind, record, recordStructureKind, refine, refineConstraintKind, regex, regexConstraintKind, required, safe, safeConstraintKind, segmentPath, segmentPathConstraintKind, strictNegative, strictNegativeConstraintKind, strictPositive, strictPositiveConstraintKind, string, stringFundamentalTypeKind, stringLengthEqual, stringLengthEqualConstraintKind, stringLiteralTypeKind, stringTypeKind, structureIdentifier, structureKind, time, timeFundamentalTypeKind, timeTypeKind, trimmed, trimmedConstraintKind, typeIdentifier, typeKind, typeStructureKind, undefinedHelper as undefined, undefinedFundamentalTypeKind, undefinedTypeKind, union, unionStructureKind, url, urlConstraintKind, uuid, uuidConstraintKind };

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

@@ -24,14 +24,14 @@ export declare const entityStructureKind: DKind.Handler<DKind.Definition<"@Duplo
 export interface EntityStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DCommon.Memoized<DDataStructure.ObjectStructure>;
 }
-export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends Entity ? GenericRawValue : GenericRawValue extends object ? DCommon.Or<[
+export type EntityMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends object ? DCommon.Or<[
     DCommon.IsExtends<GenericRawValue, readonly any[]>,
     DCommon.And<[
         DCommon.IsExtends<keyof GenericRawValue, string>,
         DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
     ]>
 ]> extends true ? {
-    [Prop in keyof GenericRawValue]: NewTypeMap<GenericRawValue[Prop]>;
+    [Prop in keyof GenericRawValue]: EntityMap<GenericRawValue[Prop]>;
 } : GenericRawValue : GenericRawValue;
 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;

package/dist/modeling/taggedObject/base.cjs

@@ -1,3 +1,9 @@
+const require_isSimple = require("../../object/isSimple.cjs");
+const require_create = require("../../either/left/create.cjs");
+const require_create$1 = require("../../either/right/create.cjs");
+const require_justExec = require("../../common/justExec.cjs");
+const require_resultSymbol = require("../../dataStructure/common/resultSymbol.cjs");
+const require_error = require("../../dataStructure/common/error.cjs");
 const require_base = require("../../dataStructure/structure/base.cjs");
 const require_nonEncodableString = require("../../dataStructure/structure/defaults/nonEncodableString.cjs");
 const require_object = require("../../dataStructure/structure/defaults/object.cjs");
@@ -16,7 +22,64 @@ const TaggedObjectStructure = require_base.createStructure(taggedObjectStructure
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
-}, { name }));
+}, {
+	name,
+	new: (self, properties) => ({
+		...properties,
+		[objectTagKind.runTimeKey]: name
+	}),
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = require_error.createGetErrorHandler();
+		const [codecs, data] = args;
+		const result = self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data, errorHandler);
+		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", result);
+	},
+	map: (self, data) => {
+		const errorHandler = require_error.createGetErrorHandler();
+		const formattedData = require_isSimple.isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		const result = self.executeCheck(formattedData, errorHandler);
+		if (result instanceof Promise) return require_create.left("async-error", void 0);
+		if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", formattedData);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return require_justExec.justExec(async () => {
+			const errorHandler = require_error.createGetErrorHandler();
+			const [codecs, data] = args;
+			const result = await self.executeDecode(codecs.context.value, require_isSimple.isSimple(data) ? {
+				...data,
+				[objectTagKind.runTimeKey]: name
+			} : data, errorHandler);
+			if (result === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+			return require_create$1.right("map-success", result);
+		});
+	},
+	asyncMap: (self, data) => require_justExec.justExec(async () => {
+		const errorHandler = require_error.createGetErrorHandler();
+		const formattedData = require_isSimple.isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		if (await self.executeCheck(formattedData, errorHandler) === require_resultSymbol.ErrorSymbol) return require_create.left("map-error", errorHandler().createError());
+		return require_create$1.right("map-success", formattedData);
+	})
+}));
 //#endregion
 exports.TaggedObjectStructure = TaggedObjectStructure;
 exports.objectTagKind = objectTagKind;

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

@@ -1,5 +1,7 @@
+import { NewType, NewTypeMap } from '../newType';
 import type * as DKind from '../../kind';
-import type * as DCommon from '../../common';
+import * as DCommon from '../../common';
+import * as DEither from '../../either';
 import * as DDataStructure from '../../dataStructure';
 declare module '../../dataStructure' {
     interface StructuresStore {
@@ -25,7 +27,23 @@ export declare const taggedObjectStructureKind: DKind.Handler<DKind.Definition<"
 export interface TaggedObjectStructureDefinition extends DDataStructure.StructureDefinition<readonly []> {
     readonly inner: DDataStructure.ObjectStructure;
 }
+export type TaggedObjectMap<GenericValue extends unknown, GenericRawValue = DCommon.RemoveConstraint<GenericValue>> = GenericRawValue extends NewType ? NewTypeMap<GenericRawValue> : GenericRawValue extends object ? DCommon.Or<[
+    DCommon.IsExtends<GenericRawValue, readonly any[]>,
+    DCommon.And<[
+        DCommon.IsExtends<keyof GenericRawValue, string>,
+        DCommon.Not<DCommon.IsExtends<DCommon.AnyFunction, GenericRawValue[keyof GenericRawValue]>>
+    ]>
+]> extends true ? {
+    [Prop in keyof GenericRawValue]: TaggedObjectMap<GenericRawValue[Prop]>;
+} : GenericRawValue : GenericRawValue;
 export interface TaggedObjectStructure<GenericTaggedObject extends ObjectTag = ObjectTag> extends DCommon.Forward<DDataStructure.Structure<GenericTaggedObject, TaggedObjectStructureDefinition> & DKind.Kind<typeof taggedObjectStructureKind>> {
     readonly name: GetTagValue<GenericTaggedObject>;
+    "new"(properties: DCommon.SimplifyTopLevel<DKind.Remove<GenericTaggedObject>>): GenericTaggedObject;
+    decodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<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<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    map(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): (DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"async-error", undefined> | DEither.Left<"map-error", DDataStructure.Error>);
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs): (data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>) => Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncDecodeMap<GenericCodecs extends DDataStructure.Codecs>(codecs: GenericCodecs, data: DDataStructure.EncodedValue<TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>, GenericCodecs>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
+    asyncMap(data: TaggedObjectMap<DKind.Remove<DDataStructure.StructureValue<this>>>): Promise<DEither.Right<"map-success", DDataStructure.StructureValue<this>> | DEither.Left<"map-error", DDataStructure.Error>>;
 }
 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/modeling/taggedObject/base.mjs

@@ -1,3 +1,9 @@
+import { isSimple } from "../../object/isSimple.mjs";
+import { left } from "../../either/left/create.mjs";
+import { right } from "../../either/right/create.mjs";
+import { justExec } from "../../common/justExec.mjs";
+import { ErrorSymbol } from "../../dataStructure/common/resultSymbol.mjs";
+import { createGetErrorHandler } from "../../dataStructure/common/error.mjs";
 import { createStructure } from "../../dataStructure/structure/base.mjs";
 import { NonEncodableStringStructure } from "../../dataStructure/structure/defaults/nonEncodableString.mjs";
 import { ObjectStructure } from "../../dataStructure/structure/defaults/object.mjs";
@@ -16,6 +22,63 @@ const TaggedObjectStructure = createStructure(taggedObjectStructureKind, ({ init
 	executeEncode: (self, codecContext, data, errorHandler) => self.definition.inner.executeEncode(codecContext, data, errorHandler),
 	executeDecode: (self, codecContext, data, errorHandler) => self.definition.inner.executeDecode(codecContext, data, errorHandler),
 	isAsynchronous: (self) => self.definition.inner.isAsynchronous()
-}, { name }));
+}, {
+	name,
+	new: (self, properties) => ({
+		...properties,
+		[objectTagKind.runTimeKey]: name
+	}),
+	decodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.decodeMap(codecs, value);
+		}
+		const errorHandler = createGetErrorHandler();
+		const [codecs, data] = args;
+		const result = self.executeDecode(codecs.context.value, isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", result);
+	},
+	map: (self, data) => {
+		const errorHandler = createGetErrorHandler();
+		const formattedData = isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		const result = self.executeCheck(formattedData, errorHandler);
+		if (result instanceof Promise) return left("async-error", void 0);
+		if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", formattedData);
+	},
+	asyncDecodeMap: (self, ...args) => {
+		if (args.length === 1) {
+			const [codecs] = args;
+			return (value) => self.asyncDecodeMap(codecs, value);
+		}
+		return justExec(async () => {
+			const errorHandler = createGetErrorHandler();
+			const [codecs, data] = args;
+			const result = await self.executeDecode(codecs.context.value, isSimple(data) ? {
+				...data,
+				[objectTagKind.runTimeKey]: name
+			} : data, errorHandler);
+			if (result === ErrorSymbol) return left("map-error", errorHandler().createError());
+			return right("map-success", result);
+		});
+	},
+	asyncMap: (self, data) => justExec(async () => {
+		const errorHandler = createGetErrorHandler();
+		const formattedData = isSimple(data) ? {
+			...data,
+			[objectTagKind.runTimeKey]: name
+		} : data;
+		if (await self.executeCheck(formattedData, errorHandler) === ErrorSymbol) return left("map-error", errorHandler().createError());
+		return right("map-success", formattedData);
+	})
+}));
 //#endregion
 export { TaggedObjectStructure, objectTagKind, taggedObjectStructureKind };

package/dist/path/getParentFolderPath.cjs

@@ -1,9 +1,13 @@
 //#region scripts/path/getParentFolderPath.ts
 const parentFolderPathRegex = /^([^]*)\/[^/]+$/;
-const onlyParentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
+const onlyParentSegmentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
 function getParentFolderPath(path) {
+	if (path === "/") return null;
+	if (path === ".") return "..";
+	if (onlyParentSegmentsRegex.test(path)) return `${path}/..`;
 	const parent = parentFolderPathRegex.exec(path)?.[1];
-	if (parent === void 0 || parent === "" || onlyParentsRegex.test(parent)) return path.startsWith("/") && parent === "" ? "/" : null;
+	if (parent === void 0) return ".";
+	if (parent === "") return "/";
 	return parent;
 }
 //#endregion

package/dist/path/getParentFolderPath.d.ts

@@ -1,2 +1,2 @@
 import { Absolute, Path } from './constraints';
-export declare function getParentFolderPath<GenericPath extends string & (Path | Absolute)>(path: GenericPath): string | null;
+export declare function getParentFolderPath<GenericPath extends string & (Path | Absolute)>(path: GenericPath): (string & Path) | null;

package/dist/path/getParentFolderPath.mjs

@@ -1,9 +1,13 @@
 //#region scripts/path/getParentFolderPath.ts
 const parentFolderPathRegex = /^([^]*)\/[^/]+$/;
-const onlyParentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
+const onlyParentSegmentsRegex = /^(?:\.\.)(?:\/\.\.)*$/;
 function getParentFolderPath(path) {
+	if (path === "/") return null;
+	if (path === ".") return "..";
+	if (onlyParentSegmentsRegex.test(path)) return `${path}/..`;
 	const parent = parentFolderPathRegex.exec(path)?.[1];
-	if (parent === void 0 || parent === "" || onlyParentsRegex.test(parent)) return path.startsWith("/") && parent === "" ? "/" : null;
+	if (parent === void 0) return ".";
+	if (parent === "") return "/";
 	return parent;
 }
 //#endregion

package/package.json

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